diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index f0f4da11c..13b3a0f33 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -11,10 +11,13 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13", "3.14"] + python-version: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14"] steps: - uses: actions/checkout@v3 + - name: Set up TA-Lib + uses: TA-Lib/setup-ta-lib@v1 + - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v4 with: @@ -26,28 +29,18 @@ jobs: pip install --upgrade pip wheel setuptools pip install -r requirements_test.txt pip install flake8 - ./tools/build_talib_from_source.bash $DEPS_PATH - env: - DEPS_PATH: ${{ github.workspace }}/dependencies - TA_INCLUDE_PATH: ${{ github.workspace }}/dependencies/include - TA_LIBRARY_PATH: ${{ github.workspace }}/dependencies/lib - name: Build cython modules in-place run: | - python setup.py build_ext --inplace --include-dirs=$TA_INCLUDE_PATH --library-dirs=$TA_LIBRARY_PATH - env: - TA_INCLUDE_PATH: ${{ github.workspace }}/dependencies/include - TA_LIBRARY_PATH: ${{ github.workspace }}/dependencies/lib + python setup.py build_ext --inplace - name: Lint with flake8 run: | # stop the build if there are Python syntax errors or undefined names - flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics + flake8 talib --count --select=E9,F63,F7,F82 --show-source --statistics # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide - #flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics + #flake8 talib --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics - name: Test with pytest run: | PYTHONPATH=. pytest - env: - LD_LIBRARY_PATH: ${{ github.workspace }}/dependencies/lib diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml new file mode 100644 index 000000000..585187e4a --- /dev/null +++ b/.github/workflows/wheels.yml @@ -0,0 +1,253 @@ + +name: Wheels +on: + push: + tags: + - "v*" + workflow_dispatch: + +env: + TALIB_C_VER: 0.7.1 + PIP_NO_VERIFY: 0 + PIP_VERBOSE: 1 + CIBW_BEFORE_BUILD: pip install -U setuptools Cython wheel meson-python ninja && pip install -U numpy + CIBW_TEST_REQUIRES: pytest pandas maturin polars + CIBW_SKIP: "pp* cp313t* cp314t*" + +jobs: + build_linux_x86_64: + name: Build Linux x86_64 wheels + strategy: + matrix: + os: ["ubuntu-24.04"] + runs-on: ${{ matrix.os }} + steps: + - name: Checkout repository + uses: actions/checkout@v4 + - name: Build wheels + uses: pypa/cibuildwheel@v3.2.1 + env: + CIBW_BEFORE_ALL: | + bash ./tools/build_talib_linux.sh + CIBW_MANYLINUX_X86_64_IMAGE: manylinux_2_28 + CIBW_MUSLLINUX_X86_64_IMAGE: musllinux_1_2 + CIBW_ENVIRONMENT_PASS_LINUX: TALIB_C_VER CFLAGS + CFLAGS: -D_GNU_SOURCE + CIBW_TEST_SKIP: "cp*-musllinux*" + CIBW_TEST_COMMAND: > + cd .. && + pytest -k "not RSI and not threading" {project}/tests + CIBW_ARCHS_LINUX: x86_64 + CIBW_BUILD_FRONTEND: build + CIBW_ENVIRONMENT_LINUX : > + TA_LIBRARY_PATH="ta-lib-install/lib" + TA_INCLUDE_PATH="ta-lib-install/include" + PIP_NO_BUILD_ISOLATION=false + CIBW_REPAIR_WHEEL_COMMAND_LINUX: | + export LD_LIBRARY_PATH="/project/ta-lib-install/lib:$LD_LIBRARY_PATH" + auditwheel repair -w {dest_dir} {wheel} + - name: Upload wheels + uses: actions/upload-artifact@v4 + with: + path: ./wheelhouse/*.whl + name: "ta_lib-${{ github.ref_name }}-linux_x86_64" + build_linux_arm64: + name: Build Linux arm64 wheels + strategy: + matrix: + os: ["ubuntu-24.04-arm"] + runs-on: ${{ matrix.os }} + steps: + - name: Checkout repository + uses: actions/checkout@v4 + - name: Build wheels + uses: pypa/cibuildwheel@v3.2.1 + env: + CIBW_BEFORE_ALL: | + bash ./tools/build_talib_linux.sh + CIBW_MANYLINUX_AARCH64_IMAGE: manylinux_2_28 + CIBW_MUSLLINUX_AARCH64_IMAGE: musllinux_1_2 + CIBW_ENVIRONMENT_PASS_LINUX: TALIB_C_VER CFLAGS + CFLAGS: -D_GNU_SOURCE + CIBW_TEST_SKIP: "cp*-musllinux*" + CIBW_TEST_COMMAND: > + cd .. && + pytest -k "not RSI and not threading" {project}/tests + CIBW_ARCHS_LINUX: aarch64 + CIBW_BUILD_FRONTEND: build + CIBW_ENVIRONMENT_LINUX : > + TA_LIBRARY_PATH="ta-lib-install/lib" + TA_INCLUDE_PATH="ta-lib-install/include" + PIP_NO_BUILD_ISOLATION=false + CIBW_REPAIR_WHEEL_COMMAND_LINUX: | + export LD_LIBRARY_PATH="/project/ta-lib-install/lib:$LD_LIBRARY_PATH" + auditwheel repair -w {dest_dir} {wheel} + - name: Upload wheels + uses: actions/upload-artifact@v4 + with: + path: ./wheelhouse/*.whl + name: "ta_lib-${{ github.ref_name }}-linux_arm64" + build_windows_amd64: + name: Build Windows amd64 wheels + strategy: + matrix: + os: ["windows-2022"] + runs-on: ${{ matrix.os }} + steps: + - name: Checkout the repository + uses: actions/checkout@v4 + - name: Set up MSVC for x64 + uses: ilammy/msvc-dev-cmd@v1 + with: + arch: amd64 + - name: Build TA-Lib C Library + run: tools/build_talib_windows.cmd + shell: cmd + - name: Build wheels + uses: pypa/cibuildwheel@v3.2.1 + env: + CIBW_TEST_SKIP: "cp*" + CIBW_TEST_COMMAND: > + cd .. && + pytest --rootdir=C: -k "not RSI and not threading" {project}/tests + MSBUILDTREATHIGHERTOOLSVERSIONASCURRENT: 1 + CIBW_ARCHS_WINDOWS: AMD64 + CIBW_ENVIRONMENT_WINDOWS: > + TA_LIBRARY_PATH="ta-lib-$TALIB_C_VER\\_build;$LIB" + TA_INCLUDE_PATH="ta-lib-$TALIB_C_VER\\include;$INCLUDE" + PIP_NO_BUILD_ISOLATION=false + - name: Upload wheel + uses: actions/upload-artifact@v4 + with: + path: ./wheelhouse/*.whl + name: "ta_lib-${{ github.ref_name }}-win_amd64" + build_windows_x86: + name: Build Windows x86 wheels + strategy: + matrix: + os: ["windows-2022"] + runs-on: ${{ matrix.os }} + steps: + - name: Checkout the repository + uses: actions/checkout@v4 + - name: Set up MSVC for x86 + uses: ilammy/msvc-dev-cmd@v1 + with: + arch: amd64_x86 + - name: Build TA-Lib C library + run: tools/build_talib_windows.cmd + shell: cmd + - name: Build wheels + uses: pypa/cibuildwheel@v3.2.1 + env: + CIBW_TEST_SKIP: "cp*" + CIBW_TEST_COMMAND: > + cd .. && + pytest --rootdir=C: -k "not RSI and not threading" {project}/tests + MSBUILDTREATHIGHERTOOLSVERSIONASCURRENT: 1 + CIBW_ARCHS_WINDOWS: x86 + CIBW_ENVIRONMENT_WINDOWS: > + TA_LIBRARY_PATH="ta-lib-$TALIB_C_VER\\_build;$LIB" + TA_INCLUDE_PATH="ta-lib-$TALIB_C_VER\\include;$INCLUDE" + PIP_NO_BUILD_ISOLATION=false + - name: Upload wheel + uses: actions/upload-artifact@v4 + with: + path: ./wheelhouse/*.whl + name: "ta_lib-${{ github.ref_name }}-win32" + build_windows_arm64: + name: Build Windows arm64 wheels + strategy: + matrix: + os: ["windows-11-arm"] + runs-on: ${{ matrix.os }} + steps: + - name: Checkout the repository + uses: actions/checkout@v4 + - name: Set up MSVC for arm + uses: ilammy/msvc-dev-cmd@v1 + with: + arch: arm64 + - name: Build TA-Lib C Library + run: tools/build_talib_windows.cmd + shell: cmd + - name: Build wheels + uses: pypa/cibuildwheel@v3.2.1 + env: + CIBW_TEST_SKIP: "cp*" + CIBW_TEST_COMMAND: > + cd .. && + pytest --rootdir=C: -k "not RSI and not threading" {project}/tests + MSBUILDTREATHIGHERTOOLSVERSIONASCURRENT: 1 + CIBW_ARCHS_WINDOWS: ARM64 + CIBW_ENVIRONMENT_WINDOWS: > + TA_LIBRARY_PATH="ta-lib-$TALIB_C_VER\\_build;$LIB" + TA_INCLUDE_PATH="ta-lib-$TALIB_C_VER\\include;$INCLUDE" + PIP_NO_BUILD_ISOLATION=false + - name: Upload wheel + uses: actions/upload-artifact@v4 + with: + path: ./wheelhouse/*.whl + name: "ta_lib-${{ github.ref_name }}-win_arm64" + build_macos_x86_64: + name: Build MacOS x86_64 wheels + strategy: + matrix: + os: [macos-15-intel] + runs-on: ${{ matrix.os }} + steps: + - name: Checkout repository + uses: actions/checkout@v4 + - name: Build wheels + uses: pypa/cibuildwheel@v3.2.1 + env: + CIBW_BEFORE_ALL: | + bash ./tools/build_talib_macos.sh + CIBW_TEST_COMMAND: > + cd .. && + pytest -k "not RSI and not threading" {project}/tests + CIBW_ARCHS_MACOS: x86_64 + CIBW_ENVIRONMENT_MACOS : > + TA_LIBRARY_PATH="ta-lib-install/lib" + TA_INCLUDE_PATH="ta-lib-install/include" + PIP_NO_BUILD_ISOLATION=false + CIBW_REPAIR_WHEEL_COMMAND_MACOS: | + export MACOSX_DEPLOYMENT_TARGET=13.7 + export DYLD_LIBRARY_PATH="/Users/runner/work/${{ github.event.repository.name }}/${{ github.event.repository.name }}/ta-lib-install/lib:$DYLD_LIBRARY_PATH" + delocate-wheel --require-archs {delocate_archs} -w {dest_dir} -v {wheel} + - name: Upload wheels + uses: actions/upload-artifact@v4 + with: + path: ./wheelhouse/*.whl + name: "ta_lib-${{ github.ref_name }}-macos_x86_64" + build_macos_arm64: + name: Build MacOS arm64 wheels + strategy: + matrix: + os: [macos-15] + runs-on: ${{ matrix.os }} + steps: + - name: Checkout repository + uses: actions/checkout@v4 + - name: Build wheels + uses: pypa/cibuildwheel@v3.2.1 + env: + CIBW_BEFORE_ALL: | + bash ./tools/build_talib_macos.sh + CIBW_TEST_COMMAND: > + cd .. && + pytest -k "not RSI and not threading" {project}/tests + CIBW_ARCHS_MACOS: arm64 + CIBW_ENVIRONMENT_MACOS : > + TA_LIBRARY_PATH="ta-lib-install/lib" + TA_INCLUDE_PATH="ta-lib-install/include" + PIP_NO_BUILD_ISOLATION=false + CIBW_REPAIR_WHEEL_COMMAND_MACOS: | + export MACOSX_DEPLOYMENT_TARGET=14.0 + export DYLD_LIBRARY_PATH="/Users/runner/work/${{ github.event.repository.name }}/${{ github.event.repository.name }}/ta-lib-install/lib:$DYLD_LIBRARY_PATH" + delocate-wheel --require-archs {delocate_archs} -w {dest_dir} -v {wheel} + - name: Upload wheels + uses: actions/upload-artifact@v4 + with: + path: ./wheelhouse/*.whl + name: "ta_lib-${{ github.ref_name }}-macos_arm64" diff --git a/CHANGELOG b/CHANGELOG index 4c6fbd7c2..56676df11 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,9 +1,54 @@ +0.7.1 +===== + +- [FIX]: Fix wheels to build with TA-Lib C 0.7.1 properly. + +0.7.0 +===== + +- [NEW]: Upgrade to Cython 3.2.8 + +- [FIX]: Adding ACCBANDS, AVGDEV, IMI to get_func_groups() + +- [FIX]: Adding ACCBANDS, AVGDEV, IMI to docs pages + +- [NEW]: Adding an ``abstract.pyi`` for typing + +0.6.8 +===== + +- [FIX]: Remove accidental cython dependency. + +- [NEW]: Upgrade to Cython 3.1.5 + +- [NEW]: Release binaries for Python 3.14 + +0.6.7 +===== + +- [NEW]: Upgrade to Cython 3.1.3 + +- [FIX]: Include .pxd files in the source .tar.gz + +- [FIX]: Don't require pip, it's not needed + +- [FIX]: Add back some import compat for backtrader + +0.6.6 +===== + +- [FIX]: Silence project.license warnings when building. + +- [FIX]: Fix regression in abstract function parameters not coercing integers + 0.6.5 ===== - [FIX]: Support PEP-517 style installation -- [NEW]: Upgrade to Cython 3.1.1 +- [NEW]: Upgrade to Cython 3.1.2 + +- [NEW]: Build binary wheels for Windows, macOS, and Linux. 0.6.4 ===== diff --git a/CITATION.cff b/CITATION.cff index 189898503..3cd0641f2 100644 --- a/CITATION.cff +++ b/CITATION.cff @@ -1,8 +1,9 @@ cff-version: 1.2.0 +message: "If you use this software, please cite it as below." title: ta-lib-python -message: >- - If you use this software, please cite it using the - metadata from this file. +version: 0.6.5 +date-released: 2025-08-07 +url: "https://github.com/ta-lib/ta-lib-python" type: software authors: - given-names: John diff --git a/DEVELOPMENT b/DEVELOPMENT index fd29fec0e..571a48a2c 100644 --- a/DEVELOPMENT +++ b/DEVELOPMENT @@ -1,11 +1,13 @@ To get started developing on talib, clone the latest code from git and install: -$ git clone git://github.com/mrjbq7/ta-lib.git -$ cd ta-lib +``` +$ git clone git://github.com/ta-lib/ta-lib-python.git +$ cd ta-lib-python # you can run "git pull" here (no quotes) to update the sources in the future $ make build $ [sudo] make install +``` Here's the full list of make commands (see the Makefile file): @@ -43,21 +45,4 @@ tools/generate_func.py,generate_stream.py about all functions from the C headers of the installed TA-Lib. If you are interested in developing new indicator functions or whatnot on -the underlying TA-Lib, you must install TA-Lib from svn. Here's how (Linux -tested): - -``` -$ cd ~/dev -$ svn checkout svn://svn.code.sf.net/p/ta-lib/code/trunk@1545 ta-lib-code -# later revisions break building ta_regtest (but claim to add support for VS2012) -$ cd ta-lib-code/ta-lib/c/make/gen_make -$ perl ./gen_make.pl -$ # cd ta-lib-code/ta-lib/c/make/cmr && make --> compile the code (no install) -$ cd ~/dev/ta-lib-code/tools -# Depending upon your platform you may need to make minor changes to this script: -$ perl ./release_unix.pl -version 0.4.X -source ../ta-lib/c -$ cd ~/ta-lib-0.4.X-work/dist -# the installable source package will be here, and if you wanted, the deb/rpm -# packages then see http://ta-lib.org/d_misc/how-to_function.html and the -# README/comments in the src -``` +the underlying TA-Lib, you must install TA-Lib from git. diff --git a/LICENSE b/LICENSE index 721ed8541..bac52bae9 100644 --- a/LICENSE +++ b/LICENSE @@ -1,3 +1,5 @@ +# BSD 2-Clause License + Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: @@ -8,14 +10,13 @@ modification, are permitted provided that the following conditions are met: this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. -THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, -INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE -DEVELOPERS AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; -OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, -WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR -OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF -ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/MANIFEST.in b/MANIFEST.in index 97961f076..44b36dba8 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -3,5 +3,6 @@ include COPYRIGHT include README.md include talib/*.c include talib/*.pyx +include talib/*.pxd include talib/*.pxi include tests/*.py diff --git a/Makefile b/Makefile index facef6e2d..d86ef416a 100644 --- a/Makefile +++ b/Makefile @@ -17,6 +17,9 @@ generate: talib/_func.pxi talib/_stream.pxi cython: cython talib/_ta_lib.pyx +annotate: + cython -a talib/_ta_lib.pyx + clean: rm -rf build talib/_ta_lib.so talib/*.pyc diff --git a/README.md b/README.md index b29c91d21..917c20a11 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,12 @@ -# TA-Lib +# TA-Lib 📈 + ![Tests](https://github.com/ta-lib/ta-lib-python/actions/workflows/tests.yml/badge.svg) +[![Release](https://img.shields.io/github/v/release/ta-lib/ta-lib-python?label=Release)](https://github.com/ta-lib/ta-lib-python/releases) +[![PyPI](https://img.shields.io/pypi/v/TA-Lib?label=PyPI)](https://pypi.org/project/TA-Lib/) +[![Wheels](https://img.shields.io/pypi/wheel/TA-Lib?label=Wheels)](https://pypi.org/project/TA-Lib/#files) +[![Python Versions](https://img.shields.io/pypi/pyversions/TA-Lib?label=Python)](https://pypi.org/project/TA-Lib/) +[![License](https://img.shields.io/badge/License-BSD%202--Clause-blue.svg)](https://opensource.org/licenses/BSD-2-Clause) This is a Python wrapper for [TA-LIB](http://ta-lib.org) based on Cython instead of SWIG. From the homepage: @@ -17,46 +23,45 @@ The original Python bindings included with TA-Lib use [SWIG](http://swig.org) which unfortunately are difficult to install and aren't as efficient as they could be. Therefore this project uses [Cython](https://cython.org) and [Numpy](https://numpy.org) to efficiently -and cleanly bind to TA-Lib -- producing results 2-4 times faster than the +and cleanly bind to TA-Lib - producing results 2-4 times faster than the SWIG interface. In addition, this project also supports the use of the [Polars](https://www.pola.rs) and [Pandas](https://pandas.pydata.org) libraries. -## Versions +## Versions 🗂️ The upstream TA-Lib C library released version 0.6.1 and changed the library -name to ``-lta-lib`` from ``-lta_lib``. After trying to support both via +name to `-lta-lib` from `-lta_lib`. After trying to support both via autodetect and having some issues, we have decided to currently support three feature branches: -* ``ta-lib-python`` 0.4.x (supports ``ta-lib`` 0.4.x and ``numpy`` 1) -* ``ta-lib-python`` 0.5.x (supports ``ta-lib`` 0.4.x and ``numpy`` 2) -* ``ta-lib-python`` 0.6.x (supports ``ta-lib`` 0.6.x and ``numpy`` 2) +* `ta-lib-python` 0.4.x (supports `ta-lib` 0.4.x and `numpy` 1) +* `ta-lib-python` 0.5.x (supports `ta-lib` 0.4.x and `numpy` 2) +* `ta-lib-python` 0.6.x (supports `ta-lib` 0.6.x and `numpy` 2) -## Installation +## Installation 💾 You can install from PyPI: -``` -$ python -m pip install TA-Lib +```shell +python -m pip install TA-Lib ``` -Or checkout the sources and run ``setup.py`` yourself: +Or checkout the sources and run `setup.py` yourself: -``` -$ python setup.py install +```shell +python setup.py install ``` -It also appears possible to install via -[Conda Forge](https://anaconda.org/conda-forge/ta-lib): +It also appears possible to install via [Conda Forge](https://anaconda.org/conda-forge/ta-lib): -``` -$ conda install -c conda-forge ta-lib +```shell +conda install -c conda-forge ta-lib ``` -### Dependencies +### Dependencies 🧩 To use TA-Lib for python, you need to have the [TA-Lib](http://ta-lib.org) already installed. You should probably follow their [installation @@ -68,100 +73,133 @@ suggestions are included below for reference. > > ``$ conda install -c conda-forge libta-lib`` -##### Mac OS X +#### Mac OS X You can simply install using Homebrew: -``` -$ brew install ta-lib +```shell +brew install ta-lib ``` If you are using Apple Silicon, such as the M1 processors, and building mixed architecture Homebrew projects, you might want to make sure it's being built for your architecture: -``` -$ arch -arm64 brew install ta-lib +```shell +arch -arm64 brew install ta-lib ``` -And perhaps you can set these before installing with ``pip``: +And perhaps you can set these before installing with `pip`: -``` -$ export TA_INCLUDE_PATH="$(brew --prefix ta-lib)/include" -$ export TA_LIBRARY_PATH="$(brew --prefix ta-lib)/lib" +```shell +export TA_INCLUDE_PATH="$(brew --prefix ta-lib)/include" +export TA_LIBRARY_PATH="$(brew --prefix ta-lib)/lib" ``` You might also find this helpful, particularly if you have tried several different installations without success: -``` -$ your-arm64-python -m pip install --no-cache-dir ta-lib +```shell +your-arm64-python -m pip install --no-cache-dir ta-lib ``` -##### Windows +#### Windows For 64-bit Windows, the easiest way is to get the *executable installer*: -1. Download [ta-lib-0.6.4-windows-x86_64.msi](https://github.com/ta-lib/ta-lib/releases/download/v0.6.4/ta-lib-0.6.4-windows-x86_64.msi). -2. Run the Installer or run ``msiexec`` [from the command-line](https://learn.microsoft.com/en-us/windows/win32/msi/standard-installer-command-line-options). +1. Download [ta-lib-0.7.1-windows-x86_64.msi](https://github.com/ta-lib/ta-lib/releases/download/v0.7.1/ta-lib-0.7.1-windows-x86_64.msi). +2. Run the Installer or run `msiexec` [from the command-line](https://learn.microsoft.com/en-us/windows/win32/msi/standard-installer-command-line-options). Alternatively, if you prefer to get the libraries without installing, or would like to use the 32-bit version: -* Intel/AMD 64-bit [ta-lib-0.6.4-windows-x86_64.zip](https://github.com/ta-lib/ta-lib/releases/download/v0.6.4/ta-lib-0.6.4-windows-x86_64.zip) -* Intel/AMD 32-bit [ta-lib-0.6.4-windows-x86_32.zip](https://github.com/ta-lib/ta-lib/releases/download/v0.6.4/ta-lib-0.6.4-windows-x86_32.zip) +* Intel/AMD 64-bit [ta-lib-0.7.1-windows-x86_64.zip](https://github.com/ta-lib/ta-lib/releases/download/v0.7.1/ta-lib-0.7.1-windows-x86_64.zip) +* Intel/AMD 32-bit [ta-lib-0.7.1-windows-x86_32.zip](https://github.com/ta-lib/ta-lib/releases/download/v0.7.1/ta-lib-0.7.1-windows-x86_32.zip) -##### Linux +#### Linux Download -[ta-lib-0.6.4-src.tar.gz](https://github.com/ta-lib/ta-lib/releases/download/v0.6.4/ta-lib-0.6.4-src.tar.gz) +[ta-lib-0.7.1-src.tar.gz](https://github.com/ta-lib/ta-lib/releases/download/v0.7.1/ta-lib-0.7.1-src.tar.gz) and: -``` -$ tar -xzf ta-lib-0.6.4-src.tar.gz -$ cd ta-lib-0.6.4/ -$ ./configure --prefix=/usr -$ make -$ sudo make install +```shell +tar -xzf ta-lib-0.7.1-src.tar.gz +cd ta-lib-0.7.1/ +./configure --prefix=/usr +make +sudo make install ``` -> If you build ``TA-Lib`` using ``make -jX`` it will fail but that's OK! +> If you build `TA-Lib` using `make -jX` it will fail but that's OK! > Simply rerun ``make -jX`` followed by ``[sudo] make install``. Note: if your directory path includes spaces, the installation will probably fail with ``No such file or directory`` errors. -### Troubleshooting +### Wheels ⚙️ + +For convenience, and starting with version 0.6.5, we now build binary wheels +for different operating systems, architectures, and Python versions using +GitHub Actions which include the underlying TA-Lib C library and are easy to +install. + +Supported platforms: + +* Linux + * x86_64 + * arm64 +* macOS + * x86_64 + * arm64 +* Windows + * x86_64 + * x86 + * arm64 + +Supported Python versions: + +* 3.9 +* 3.10 +* 3.11 +* 3.12 +* 3.13 +* 3.14 + +In the event that your operating system, architecture, or Python version are +not available as a binary wheel, it is fairly easy to install from source +using the instructions above. + +### Troubleshooting 🛠️ If you get a warning that looks like this: -``` +```shell setup.py:79: UserWarning: Cannot find ta-lib library, installation may fail. warnings.warn('Cannot find ta-lib library, installation may fail.') ``` -This typically means ``setup.py`` can't find the underlying ``TA-Lib`` +This typically means `setup.py` can't find the underlying `TA-Lib` library, a dependency which needs to be installed. --- -If you installed the underlying ``TA-Lib`` library with a custom prefix -(e.g., with ``./configure --prefix=$PREFIX``), then when you go to install +If you installed the underlying `TA-Lib` library with a custom prefix +(e.g., with `./configure --prefix=$PREFIX`), then when you go to install this python wrapper you can specify additional search paths to find the -library and include files for the underlying ``TA-Lib`` library using the -``TA_LIBRARY_PATH`` and ``TA_INCLUDE_PATH`` environment variables: +library and include files for the underlying `TA-Lib` library using the +`TA_LIBRARY_PATH` and `TA_INCLUDE_PATH` environment variables: -```sh -$ export TA_LIBRARY_PATH=$PREFIX/lib -$ export TA_INCLUDE_PATH=$PREFIX/include -$ python setup.py install # or pip install ta-lib +```shell +export TA_LIBRARY_PATH=$PREFIX/lib +export TA_INCLUDE_PATH=$PREFIX/include +python setup.py install # or pip install ta-lib ``` --- Sometimes installation will produce build errors like this: -``` +```shell talib/_ta_lib.c:601:10: fatal error: ta-lib/ta_defs.h: No such file or directory 601 | #include "ta-lib/ta_defs.h" | ^~~~~~~~~~~~~~~~~~ @@ -170,7 +208,7 @@ compilation terminated. or: -``` +```shell common.obj : error LNK2001: unresolved external symbol TA_SetUnstablePeriod common.obj : error LNK2001: unresolved external symbol TA_Shutdown common.obj : error LNK2001: unresolved external symbol TA_Initialize @@ -178,16 +216,16 @@ common.obj : error LNK2001: unresolved external symbol TA_GetUnstablePeriod common.obj : error LNK2001: unresolved external symbol TA_GetVersionString ``` -This typically means that it can't find the underlying ``TA-Lib`` library, a +This typically means that it can't find the underlying `TA-Lib` library, a dependency which needs to be installed. On Windows, this could be caused by -installing the 32-bit binary distribution of the underlying ``TA-Lib`` library, +installing the 32-bit binary distribution of the underlying `TA-Lib` library, but trying to use it with 64-bit Python. --- Sometimes installation will fail with errors like this: -``` +```shell talib/common.c:8:22: fatal error: pyconfig.h: No such file or directory #include "pyconfig.h" ^ @@ -198,31 +236,31 @@ error: command 'x86_64-linux-gnu-gcc' failed with exit status 1 This typically means that you need the Python headers, and should run something like: -``` -$ sudo apt-get install python3-dev +```shell +sudo apt-get install python3-dev ``` --- -Sometimes building the underlying ``TA-Lib`` library has errors running -``make`` that look like this: +Sometimes building the underlying `TA-Lib` library has errors running +`make` that look like this: -``` +```shell ../libtool: line 1717: cd: .libs/libta_lib.lax/libta_abstract.a: No such file or directory make[2]: *** [libta_lib.la] Error 1 make[1]: *** [all-recursive] Error 1 make: *** [all-recursive] Error 1 ``` -This might mean that the directory path to the underlying ``TA-Lib`` library +This might mean that the directory path to the underlying `TA-Lib` library has spaces in the directory names. Try putting it in a path that does not have any spaces and trying again. --- -Sometimes you might get this error running ``setup.py``: +Sometimes you might get this error running `setup.py`: -``` +```shell /usr/include/limits.h:26:10: fatal error: bits/libc-header-start.h: No such file or directory #include ^~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -236,7 +274,7 @@ first answer to [this question](https://stackoverflow.com/questions/54082459/fat If you get an error on macOS like this: -``` +```shell code signature in <141BC883-189B-322C-AE90-CBF6B5206F67> 'python3.9/site-packages/talib/_ta_lib.cpython-39-darwin.so' not valid for use in process: Trying to load an unsigned library) @@ -247,9 +285,9 @@ and use ``xcrun codesign`` to fix it. --- -If you wonder why ``STOCHRSI`` gives you different results than you expect, -probably you want ``STOCH`` applied to ``RSI``, which is a little different -than the ``STOCHRSI`` which is ``STOCHF`` applied to ``RSI``: +If you wonder why `STOCHRSI` gives you different results than you expect, +probably you want `STOCH` applied to `RSI`, which is a little different +than the `STOCHRSI` which is `STOCHF` applied to `RSI`: ```python >>> import talib @@ -270,16 +308,15 @@ than the ``STOCHRSI`` which is ``STOCHF`` applied to ``RSI``: --- -If the build appears to hang, you might be running on a VM with not enough -memory -- try 1 GB or 2 GB. +If the build appears to hang, you might be running on a VM with not enough memory - try 1 GB or 2 GB. It has also been reported that using a swapfile could help, for example: -``` -$ sudo fallocate -l 1G /swapfile -$ sudo chmod 600 /swapfile -$ sudo mkswap /swapfile -$ sudo swapon /swapfile +```shell +sudo fallocate -l 1G /swapfile +sudo chmod 600 /swapfile +sudo mkswap /swapfile +sudo swapon /swapfile ``` --- @@ -288,7 +325,7 @@ If you get "permission denied" errors such as this, you might need to give your user access to the location where the underlying TA-Lib C library is installed -- or install it to a user-accessible location. -``` +```shell talib/_ta_lib.c:747:28: fatal error: /usr/include/ta-lib/ta_defs.h: Permission denied #include "ta-lib/ta-defs.h" ^ @@ -300,24 +337,24 @@ error: command 'gcc' failed with exit status 1 If you're having trouble compiling the underlying TA-Lib C library on ARM64, you might need to configure it with an explicit build type before running -``make`` and ``make install``, for example: +`make` and `make install`, for example: -``` -$ ./configure --build=aarch64-unknown-linux-gnu +```shell +./configure --build=aarch64-unknown-linux-gnu ``` -This is caused by old ``config.guess`` file, so another way to solve this is +This is caused by old `config.guess` file, so another way to solve this is to copy a newer version of config.guess into the underlying TA-Lib C library sources: -``` -$ cp /usr/share/automake-1.16/config.guess /path/to/extracted/ta-lib/config.guess +```shell +cp /usr/share/automake-1.16/config.guess /path/to/extracted/ta-lib/config.guess ``` And then re-run configure: -``` -$ ./configure +```shell +./configure ``` --- @@ -325,34 +362,33 @@ $ ./configure If you're having trouble using [PyInstaller](https://pyinstaller.org) and get an error that looks like this: -``` +```shell ...site-packages\PyInstaller\loader\pyimod03_importers.py", line 493, in exec_module exec(bytecode, module.__dict__) File "talib\__init__.py", line 72, in ModuleNotFoundError: No module named 'talib.stream' ``` -Then, perhaps you can use the ``--hidden-import`` argument to fix this: +Then, perhaps you can use the `--hidden-import` argument to fix this: -``` -$ pyinstaller --hidden-import talib.stream "replaceToYourFileName.py" +```shell +pyinstaller --hidden-import talib.stream "replaceToYourFileName.py" ``` --- -If you want to use ``numpy<2``, then you should use ``ta-lib<0.5``. +If you want to use `numpy<2`, then you should use `ta-lib<0.5`. -If you want to use ``numpy>=2``, then you should use ``ta-lib>=0.5``. +If you want to use `numpy>=2`, then you should use `ta-lib>=0.5`. --- If you have trouble getting the code autocompletions to work in Visual -Studio Code, a suggestion was made to look for the ``Python`` extension -settings, and an option for ``Language Server``, and change it from -``Default`` (which means ``Pylance if it is installed, Jedi otherwise``, to -manually set ``Jedi`` and the completions should work. It is possible that -you might need to [install it -manually](https://github.com/pappasam/jedi-language-server) for this to +Studio Code, a suggestion was made to look for the `Python` extension +settings, and an option for `Language Server`, and change it from +`Default` (which means `Pylance if it is installed, Jedi otherwise`), to +manually set `Jedi` and the completions should work. It is possible that +you might need to [install it manually](https://github.com/pappasam/jedi-language-server) for this to work. ## Function API @@ -363,10 +399,15 @@ exposed TA-Lib indicators. Each function returns an output array and have default values for their parameters, unless specified as keyword arguments. Typically, these functions will have an initial "lookback" period (a required number of observations -before an output is generated) set to ``NaN``. +before an output is generated) set to `NaN`. -For convenience, the Function API supports both ``numpy.ndarray`` and -``pandas.Series`` and ``polars.Series`` inputs. +The lookback is function-specific and does not always match the value passed +to `timeperiod`. For example, `RSI(timeperiod=14)` needs 15 price observations +because the first RSI value depends on 14 price changes between consecutive +bars, not just 14 raw prices. + +For convenience, the Function API supports both `numpy.ndarray` and +`pandas.Series` and `polars.Series` inputs. All of the following examples use the Function API: @@ -397,7 +438,11 @@ Calculating momentum of the close prices, with a time period of 5: output = talib.MOM(close, timeperiod=5) ``` -##### NaN's +Functions marked in the docs as having an unstable period start with that +extra unstable-period setting at `0`. In other words, `get_unstable_period()` +returns `0` until you explicitly change it with `set_unstable_period()`. + +### NaN's The underlying TA-Lib C library handles NaN's in a sometimes surprising manner by typically propagating NaN's to the end of the output, for example: @@ -508,10 +553,10 @@ latest = stream.SMA(close) assert (output[-1] - latest) < 0.00001 ``` -## Supported Indicators and Functions +## Supported Indicators and Functions 📋 -We can show all the TA functions supported by TA-Lib, either as a ``list`` or -as a ``dict`` sorted by group (e.g. "Overlap Studies", "Momentum Indicators", +We can show all the TA functions supported by TA-Lib, either as a `list` or +as a `dict` sorted by group (e.g. "Overlap Studies", "Momentum Indicators", etc): ```python @@ -528,7 +573,7 @@ for group, names in talib.get_function_groups().items(): print(f" {name}") ``` -### Indicator Groups +### Indicator Groups 🏷️ * Overlap Studies * Momentum Indicators @@ -538,8 +583,9 @@ for group, names in talib.get_function_groups().items(): * Cycle Indicators * Pattern Recognition -##### Overlap Studies -``` +#### Overlap Studies + +```text BBANDS Bollinger Bands DEMA Double Exponential Moving Average EMA Exponential Moving Average @@ -559,8 +605,9 @@ TRIMA Triangular Moving Average WMA Weighted Moving Average ``` -##### Momentum Indicators -``` +#### Momentum Indicators + +```text ADX Average Directional Movement Index ADXR Average Directional Movement Index Rating APO Absolute Price Oscillator @@ -593,15 +640,17 @@ ULTOSC Ultimate Oscillator WILLR Williams' %R ``` -##### Volume Indicators -``` +#### Volume Indicators + +```text AD Chaikin A/D Line ADOSC Chaikin A/D Oscillator OBV On Balance Volume ``` -##### Cycle Indicators -``` +#### Cycle Indicators + +```text HT_DCPERIOD Hilbert Transform - Dominant Cycle Period HT_DCPHASE Hilbert Transform - Dominant Cycle Phase HT_PHASOR Hilbert Transform - Phasor Components @@ -609,23 +658,26 @@ HT_SINE Hilbert Transform - SineWave HT_TRENDMODE Hilbert Transform - Trend vs Cycle Mode ``` -##### Price Transform -``` +#### Price Transform + +```text AVGPRICE Average Price MEDPRICE Median Price TYPPRICE Typical Price WCLPRICE Weighted Close Price ``` -##### Volatility Indicators -``` +#### Volatility Indicators + +```text ATR Average True Range NATR Normalized Average True Range TRANGE True Range ``` -##### Pattern Recognition -``` +#### Pattern Recognition + +```text CDL2CROWS Two Crows CDL3BLACKCROWS Three Black Crows CDL3INSIDE Three Inside Up/Down @@ -689,8 +741,9 @@ CDLUPSIDEGAP2CROWS Upside Gap Two Crows CDLXSIDEGAP3METHODS Upside/Downside Gap Three Methods ``` -##### Statistic Functions -``` +#### Statistic Functions + +```text BETA Beta CORREL Pearson's Correlation Coefficient (r) LINEARREG Linear Regression diff --git a/docs/func.md b/docs/func.md index 11d4efc09..0e25d7bda 100644 --- a/docs/func.md +++ b/docs/func.md @@ -8,6 +8,10 @@ parameters, unless specified as keyword arguments. Typically, these functions will have an initial "lookback" period (a required number of observations before an output is generated) set to ``NaN``. +The lookback is function-specific and may be larger than the `timeperiod` +parameter. For example, ``RSI(timeperiod=14)`` needs 15 price observations, +because the first RSI value is derived from 14 consecutive price changes. + All of the following examples use the function API: ```python @@ -37,6 +41,10 @@ Calculating momentum of the close prices, with a time period of 5: output = talib.MOM(close, timeperiod=5) ``` +Functions documented as having an unstable period start with that extra +unstable-period setting at ``0``. ``get_unstable_period()`` only returns a +non-zero value after you set one explicitly with ``set_unstable_period()``. + Documentation for all functions: * [Overlap Studies](func_groups/overlap_studies.md) diff --git a/docs/func_groups/momentum_indicators.md b/docs/func_groups/momentum_indicators.md index ea2fa6401..c859d89b2 100644 --- a/docs/func_groups/momentum_indicators.md +++ b/docs/func_groups/momentum_indicators.md @@ -48,6 +48,12 @@ NOTE: The ``DX`` function has an unstable period. real = DX(high, low, close, timeperiod=14) ``` +### IMI - Intraday Momentum Index +NOTE: The ``IMI`` function has an unstable period. +```python +real = IMI(open, close, timeperiod=14) +``` + ### MACD - Moving Average Convergence/Divergence ```python macd, macdsignal, macdhist = MACD(real, fastperiod=12, slowperiod=26, signalperiod=9) diff --git a/docs/func_groups/overlap_studies.md b/docs/func_groups/overlap_studies.md index 4625ca85b..8c6305223 100644 --- a/docs/func_groups/overlap_studies.md +++ b/docs/func_groups/overlap_studies.md @@ -1,4 +1,9 @@ # Overlap Studies Functions +### ACCBANDS - Acceleration Bands +```python +upperband, middleband, lowerband = ACCBANDS(high, low, close, timeperiod=20) +``` + ### BBANDS - Bollinger Bands ```python upperband, middleband, lowerband = BBANDS(real, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0) diff --git a/docs/func_groups/price_transform.md b/docs/func_groups/price_transform.md index 1f79b1962..3bf5e132e 100644 --- a/docs/func_groups/price_transform.md +++ b/docs/func_groups/price_transform.md @@ -1,4 +1,9 @@ # Price Transform Functions +### AVGDEV - Average Deviation +```python +real = AVGDEV(real, timeperiod=14) +``` + ### AVGPRICE - Average Price ```python real = AVGPRICE(open, high, low, close) @@ -21,5 +26,4 @@ real = WCLPRICE(high, low, close) [Documentation Index](../doc_index.md) - -[FLOAT_RIGHTAll Function Groups](../funcs.md) \ No newline at end of file +[FLOAT_RIGHTAll Function Groups](../funcs.md) diff --git a/docs/generate_html_pages.py b/docs/generate_html_pages.py index 4656ee7f5..fe8633353 100644 --- a/docs/generate_html_pages.py +++ b/docs/generate_html_pages.py @@ -13,8 +13,6 @@ # default, lovelace and xcode are "normal" styles """ -from __future__ import print_function - import os import sys import talib @@ -103,10 +101,7 @@ def get_doc_links(): with open(html_file_path, 'r') as f: html = f.read() else: - if sys.version_info < (2, 8): - from urllib2 import urlopen - else: - from urllib.request import urlopen + from urllib.request import urlopen html = urlopen(tadoc_homepage).read() with open(html_file_path, 'wb') as f: @@ -114,7 +109,7 @@ def get_doc_links(): # find every link that's for an indicator and convert to absolute urls soup = BeautifulSoup(html, 'html.parser') - links = [a for a in soup.findAll('a') if 'indicator' in a['href']] + links = [a for a in soup.find_all('a') if 'indicator' in a['href']] ret = {} for a in links: url = ''.join([tadoc_homepage, a['href']]) diff --git a/docs/index.md b/docs/index.md index efe01ac12..2f192de02 100644 --- a/docs/index.md +++ b/docs/index.md @@ -28,6 +28,10 @@ parameters, unless specified as keyword arguments. Typically, these functions will have an initial "lookback" period (a required number of observations before an output is generated) set to ``NaN``. +The lookback is function-specific and may be larger than the `timeperiod` +parameter. For example, ``RSI(timeperiod=14)`` needs 15 price observations, +because the first RSI value is based on 14 consecutive price changes. + All of the following examples use the function API: ```python @@ -57,6 +61,10 @@ Calculating momentum of the close prices, with a time period of 5: output = talib.MOM(close, timeperiod=5) ``` +Functions documented as having an unstable period start with that extra +unstable-period setting at ``0``. ``get_unstable_period()`` only reports a +non-zero value after you call ``set_unstable_period()`` yourself. + ## Abstract API Quick Start If you're already familiar with using the function API, you should feel right diff --git a/pyproject.toml b/pyproject.toml index 3e6a2b7c3..dce4d7d21 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,10 +4,10 @@ build-backend = "setuptools.build_meta" [project] name = "TA-Lib" -version = "0.6.5" +version = "0.7.1" description = "Python wrapper for TA-Lib" readme = "README.md" -license = { text = "BSD-2-Clause" } +license-files = ["LICENSE"] authors = [ {name = "John Benediktsson", email = "mrjbq7@gmail.com"} ] @@ -19,15 +19,7 @@ classifiers = [ "Operating System :: MacOS :: MacOS X", "Operating System :: Microsoft :: Windows", "Programming Language :: Python", - "Programming Language :: Python :: 2", - "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", - "Programming Language :: Python :: 3.3", - "Programming Language :: Python :: 3.4", - "Programming Language :: Python :: 3.5", - "Programming Language :: Python :: 3.6", - "Programming Language :: Python :: 3.7", - "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", @@ -44,9 +36,9 @@ classifiers = [ dependencies = [ "build", "numpy", - "pip", ] +requires-python = '>=3.9' [tool.setuptools] packages = ["talib"] -package-data = {"talib" = ["_ta_lib.pyi", "py.typed"]} +package-data = {"talib" = ["_ta_lib.pyi", "py.typed", "abstract.pyi"]} diff --git a/setup.py b/setup.py index 67aec9a4f..874983353 100644 --- a/setup.py +++ b/setup.py @@ -6,7 +6,8 @@ import warnings from setuptools import setup, Extension -from setuptools.dist import Distribution + +import numpy platform_supported = False @@ -56,12 +57,6 @@ if not platform_supported: raise NotImplementedError(sys.platform) -try: - from Cython.Distutils import build_ext as cython_build_ext - has_cython = True -except ImportError: - has_cython = False - for path in library_dirs: try: files = os.listdir(path) @@ -72,14 +67,13 @@ else: warnings.warn('Cannot find ta-lib library, installation may fail.') - -import numpy - # Get the Cython build_ext or fall back to setuptools build_ext -if has_cython: +try: from Cython.Distutils import build_ext -else: + has_cython = True +except ImportError: from setuptools.command.build_ext import build_ext + has_cython = False class NumpyBuildExt(build_ext): """ diff --git a/talib/__init__.py b/talib/__init__.py index 055fac2ad..63ac18cc9 100644 --- a/talib/__init__.py +++ b/talib/__init__.py @@ -132,7 +132,7 @@ def wrapper(*args, **kwds): setattr(stream, func_name, wrapped_func) globals()[stream_func_name] = wrapped_func -__version__ = '0.6.5' +__version__ = '0.7.1' # In order to use this python library, talib (i.e. this __file__) will be # imported at some point, either explicitly or indirectly via talib.func @@ -192,6 +192,7 @@ def wrapper(*args, **kwds): 'CCI', 'CMO', 'DX', + 'IMI', 'MACD', 'MACDEXT', 'MACDFIX', @@ -215,6 +216,7 @@ def wrapper(*args, **kwds): 'WILLR', ], 'Overlap Studies': [ + 'ACCBANDS', 'BBANDS', 'DEMA', 'EMA', @@ -297,6 +299,7 @@ def wrapper(*args, **kwds): 'CDLXSIDEGAP3METHODS', ], 'Price Transform': [ + 'AVGDEV', 'AVGPRICE', 'MEDPRICE', 'TYPPRICE', diff --git a/talib/_abstract.pxi b/talib/_abstract.pxi index 8fb8089ae..6989ab80d 100644 --- a/talib/_abstract.pxi +++ b/talib/_abstract.pxi @@ -696,9 +696,7 @@ def _ta_getOptInputParameterInfo(char *function_name, int idx): name = bytes2str(info.paramName) name = name[len('optIn'):].lower() - default_value = info.defaultValue - if default_value % 1 == 0 and info.type > 1: - default_value = int(default_value) + default_value = int(info.defaultValue) if info.type > 1 else info.defaultValue return { 'name': name, diff --git a/talib/_ta_lib.c b/talib/_ta_lib.c index 79a6283d4..a7c2f6735 100644 --- a/talib/_ta_lib.c +++ b/talib/_ta_lib.c @@ -1,31 +1,50 @@ -/* Generated by Cython 3.1.1 */ +/* Generated by Cython 3.2.8 */ /* BEGIN: Cython Metadata { "distutils": { "depends": [ - "/opt/homebrew/opt/ta-lib/include/ta-lib/ta_abstract.h", - "/opt/homebrew/opt/ta-lib/include/ta-lib/ta_common.h", - "/opt/homebrew/opt/ta-lib/include/ta-lib/ta_defs.h", - "/opt/homebrew/opt/ta-lib/include/ta-lib/ta_func.h", - "/private/var/folders/47/nmnxzkvs7vn7147wn2xrcrj80000gn/T/pip-build-env-22rmtgys/overlay/lib/python3.12/site-packages/numpy/_core/include/numpy/arrayobject.h", - "/private/var/folders/47/nmnxzkvs7vn7147wn2xrcrj80000gn/T/pip-build-env-22rmtgys/overlay/lib/python3.12/site-packages/numpy/_core/include/numpy/arrayscalars.h", - "/private/var/folders/47/nmnxzkvs7vn7147wn2xrcrj80000gn/T/pip-build-env-22rmtgys/overlay/lib/python3.12/site-packages/numpy/_core/include/numpy/ndarrayobject.h", - "/private/var/folders/47/nmnxzkvs7vn7147wn2xrcrj80000gn/T/pip-build-env-22rmtgys/overlay/lib/python3.12/site-packages/numpy/_core/include/numpy/ndarraytypes.h", - "/private/var/folders/47/nmnxzkvs7vn7147wn2xrcrj80000gn/T/pip-build-env-22rmtgys/overlay/lib/python3.12/site-packages/numpy/_core/include/numpy/ufuncobject.h" + "/Users/jbenedik/.cache/uv/builds-v0/.tmpW1VPkd/lib/python3.12/site-packages/numpy/_core/include/numpy/arrayobject.h", + "/Users/jbenedik/.cache/uv/builds-v0/.tmpW1VPkd/lib/python3.12/site-packages/numpy/_core/include/numpy/arrayscalars.h", + "/Users/jbenedik/.cache/uv/builds-v0/.tmpW1VPkd/lib/python3.12/site-packages/numpy/_core/include/numpy/ndarrayobject.h", + "/Users/jbenedik/.cache/uv/builds-v0/.tmpW1VPkd/lib/python3.12/site-packages/numpy/_core/include/numpy/ndarraytypes.h", + "/Users/jbenedik/.cache/uv/builds-v0/.tmpW1VPkd/lib/python3.12/site-packages/numpy/_core/include/numpy/ufuncobject.h", + "/opt/homebrew/include/ta-lib/ta_abstract.h", + "/opt/homebrew/include/ta-lib/ta_common.h", + "/opt/homebrew/include/ta-lib/ta_defs.h", + "/opt/homebrew/include/ta-lib/ta_func.h" ], "include_dirs": [ + "/usr/include", + "/usr/local/include", + "/opt/include", + "/opt/local/include", + "/opt/homebrew/include", "/opt/homebrew/opt/ta-lib/include", - "/private/var/folders/47/nmnxzkvs7vn7147wn2xrcrj80000gn/T/pip-build-env-22rmtgys/overlay/lib/python3.12/site-packages/numpy/_core/include" + "/Users/jbenedik/.cache/uv/builds-v0/.tmpW1VPkd/lib/python3.12/site-packages/numpy/_core/include" ], "libraries": [ "ta-lib" ], "library_dirs": [ + "/usr/lib", + "/usr/local/lib", + "/usr/lib64", + "/usr/local/lib64", + "/opt/lib", + "/opt/local/lib", + "/opt/homebrew/lib", "/opt/homebrew/opt/ta-lib/lib" ], "name": "talib._ta_lib", "runtime_library_dirs": [ + "/usr/lib", + "/usr/local/lib", + "/usr/lib64", + "/usr/local/lib64", + "/opt/lib", + "/opt/local/lib", + "/opt/homebrew/lib", "/opt/homebrew/opt/ta-lib/lib" ], "sources": [ @@ -40,8 +59,16 @@ END: Cython Metadata */ #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ /* InitLimitedAPI */ -#if defined(Py_LIMITED_API) && !defined(CYTHON_LIMITED_API) +#if defined(Py_LIMITED_API) + #if !defined(CYTHON_LIMITED_API) #define CYTHON_LIMITED_API 1 + #endif +#elif defined(CYTHON_LIMITED_API) + #ifdef _MSC_VER + #pragma message ("Limited API usage is enabled with 'CYTHON_LIMITED_API' but 'Py_LIMITED_API' does not define a Python target version. Consider setting 'Py_LIMITED_API' instead.") + #else + #warning Limited API usage is enabled with 'CYTHON_LIMITED_API' but 'Py_LIMITED_API' does not define a Python target version. Consider setting 'Py_LIMITED_API' instead. + #endif #endif #include "Python.h" @@ -50,8 +77,8 @@ END: Cython Metadata */ #elif PY_VERSION_HEX < 0x03080000 #error Cython requires Python 3.8+. #else -#define __PYX_ABI_VERSION "3_1_1" -#define CYTHON_HEX_VERSION 0x030101F0 +#define __PYX_ABI_VERSION "3_2_8" +#define CYTHON_HEX_VERSION 0x030208F0 #define CYTHON_FUTURE_DIVISION 0 /* CModulePreamble */ #include @@ -76,9 +103,6 @@ END: Cython Metadata */ #define DL_EXPORT(t) t #endif #define __PYX_COMMA , -#ifndef HAVE_LONG_LONG - #define HAVE_LONG_LONG -#endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif @@ -111,7 +135,7 @@ END: Cython Metadata */ #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS - #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_ASSUME_SAFE_SIZE @@ -148,6 +172,8 @@ END: Cython Metadata */ #endif #undef CYTHON_USE_FREELISTS #define CYTHON_USE_FREELISTS 0 + #undef CYTHON_IMMORTAL_CONSTANTS + #define CYTHON_IMMORTAL_CONSTANTS 0 #elif defined(PYPY_VERSION) #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_CPYTHON 0 @@ -215,6 +241,8 @@ END: Cython Metadata */ #endif #undef CYTHON_USE_FREELISTS #define CYTHON_USE_FREELISTS 0 + #undef CYTHON_IMMORTAL_CONSTANTS + #define CYTHON_IMMORTAL_CONSTANTS 0 #elif defined(CYTHON_LIMITED_API) #ifdef Py_LIMITED_API #undef __PYX_LIMITED_VERSION_HEX @@ -225,8 +253,6 @@ END: Cython Metadata */ #define CYTHON_COMPILING_IN_LIMITED_API 1 #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 - #undef CYTHON_CLINE_IN_TRACEBACK - #define CYTHON_CLINE_IN_TRACEBACK 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_TYPE_SPECS @@ -286,8 +312,11 @@ END: Cython Metadata */ #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif - #undef CYTHON_USE_FREELISTS - #define CYTHON_USE_FREELISTS 0 + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 1 + #endif + #undef CYTHON_IMMORTAL_CONSTANTS + #define CYTHON_IMMORTAL_CONSTANTS 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 1 @@ -394,6 +423,15 @@ END: Cython Metadata */ #ifndef CYTHON_USE_FREELISTS #define CYTHON_USE_FREELISTS (!CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) #endif + #if defined(CYTHON_IMMORTAL_CONSTANTS) && PY_VERSION_HEX < 0x030C0000 + #undef CYTHON_IMMORTAL_CONSTANTS + #define CYTHON_IMMORTAL_CONSTANTS 0 // definitely won't work + #elif !defined(CYTHON_IMMORTAL_CONSTANTS) + #define CYTHON_IMMORTAL_CONSTANTS (PY_VERSION_HEX >= 0x030C0000 && !CYTHON_USE_MODULE_STATE && CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) + #endif +#endif +#ifndef CYTHON_COMPRESS_STRINGS + #define CYTHON_COMPRESS_STRINGS 1 #endif #ifndef CYTHON_FAST_PYCCALL #define CYTHON_FAST_PYCCALL CYTHON_FAST_PYCALL @@ -402,10 +440,9 @@ END: Cython Metadata */ #if CYTHON_COMPILING_IN_LIMITED_API #define CYTHON_VECTORCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) #else -#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL) #endif #endif -#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) #if CYTHON_USE_PYLONG_INTERNALS #undef SHIFT #undef BASE @@ -466,7 +503,7 @@ END: Cython Metadata */ #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) #endif #ifndef CYTHON_NCP_UNUSED -# if CYTHON_COMPILING_IN_CPYTHON +# if CYTHON_COMPILING_IN_CPYTHON && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED @@ -481,35 +518,8 @@ END: Cython Metadata */ #endif #endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) -#ifdef _MSC_VER - #ifndef _MSC_STDINT_H_ - #if _MSC_VER < 1300 - typedef unsigned char uint8_t; - typedef unsigned short uint16_t; - typedef unsigned int uint32_t; - #else - typedef unsigned __int8 uint8_t; - typedef unsigned __int16 uint16_t; - typedef unsigned __int32 uint32_t; - #endif - #endif - #if _MSC_VER < 1300 - #ifdef _WIN64 - typedef unsigned long long __pyx_uintptr_t; - #else - typedef unsigned int __pyx_uintptr_t; - #endif - #else - #ifdef _WIN64 - typedef unsigned __int64 __pyx_uintptr_t; - #else - typedef unsigned __int32 __pyx_uintptr_t; - #endif - #endif -#else - #include - typedef uintptr_t __pyx_uintptr_t; -#endif +#include +typedef uintptr_t __pyx_uintptr_t; #ifndef CYTHON_FALLTHROUGH #if defined(__cplusplus) /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 @@ -552,9 +562,9 @@ END: Cython Metadata */ #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) #endif #if CYTHON_COMPILING_IN_PYPY == 1 - #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX < 0x030A0000) #else - #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX < 0x03090000) #endif #define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) @@ -658,6 +668,12 @@ static int __Pyx_init_co_variables(void); #ifndef Py_TPFLAGS_MAPPING #define Py_TPFLAGS_MAPPING 0 #endif +#ifndef Py_TPFLAGS_IMMUTABLETYPE + #define Py_TPFLAGS_IMMUTABLETYPE (1UL << 8) +#endif +#ifndef Py_TPFLAGS_DISALLOW_INSTANTIATION + #define Py_TPFLAGS_DISALLOW_INSTANTIATION (1UL << 7) +#endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif @@ -690,11 +706,6 @@ static int __Pyx_init_co_variables(void); #define __pyx_vectorcallfunc vectorcallfunc #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) -#elif CYTHON_BACKPORT_VECTORCALL - typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, - size_t nargsf, PyObject *kwnames); - #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) - #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) #else #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) @@ -724,7 +735,7 @@ static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void (*cfunc)(vo #endif } #define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) -#if __PYX_LIMITED_VERSION_HEX < 0x03090000 +#if PY_VERSION_HEX < 0x03090000 || (CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000) #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); #else @@ -741,6 +752,9 @@ static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void (*cfunc)(vo #endif #if CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_PyFrame_SetLineNumber(frame, lineno) +#elif CYTHON_COMPILING_IN_GRAAL && defined(GRAALPY_VERSION_NUM) && GRAALPY_VERSION_NUM > 0x19000000 + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) GraalPyFrame_SetLineNumber((frame), (lineno)) #elif CYTHON_COMPILING_IN_GRAAL #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) _PyFrame_SetLineNumber((frame), (lineno)) @@ -831,7 +845,7 @@ static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) #endif #define __Pyx_PyObject_GetIterNextFunc(iterator) __Pyx_PyObject_GetSlot(iterator, tp_iternext, iternextfunc) -#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 +#if CYTHON_USE_TYPE_SPECS #define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ PyTypeObject *type = Py_TYPE((PyObject*)obj);\ assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ @@ -895,7 +909,10 @@ static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, #endif #endif #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && PyUnstable_Object_IsUniquelyReferenced(obj)) ? __Pyx_NewRef(obj) : PySequence_List(obj)) +#elif CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PySequence_ListKeepNew(obj)\ (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) #else @@ -911,15 +928,45 @@ static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif -#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS +enum __Pyx_ReferenceSharing { + __Pyx_ReferenceSharing_DefinitelyUnique, // We created it so we know it's unshared - no need to check + __Pyx_ReferenceSharing_OwnStrongReference, + __Pyx_ReferenceSharing_FunctionArgument, + __Pyx_ReferenceSharing_SharedReference, // Never trust it to be unshared because it's a global or similar +}; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && PY_VERSION_HEX >= 0x030E0000 +#define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing)\ + (sharing == __Pyx_ReferenceSharing_DefinitelyUnique ? 1 :\ + (sharing == __Pyx_ReferenceSharing_FunctionArgument ? PyUnstable_Object_IsUniqueReferencedTemporary(o) :\ + (sharing == __Pyx_ReferenceSharing_OwnStrongReference ? PyUnstable_Object_IsUniquelyReferenced(o) : 0))) +#elif (CYTHON_COMPILING_IN_CPYTHON && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing) (((void)sharing), Py_REFCNT(o) == 1) +#else +#define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing) (((void)o), ((void)sharing), 0) +#endif +#if CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i) + #elif CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PyList_GetItemRef(o, i) (likely((i) >= 0) ? PySequence_GetItem(o, i) : (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) #else - #define __Pyx_PyList_GetItemRef(o, i) PySequence_GetItem(o, i) + #define __Pyx_PyList_GetItemRef(o, i) PySequence_ITEM(o, i) + #endif +#elif CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i) + #else + #define __Pyx_PyList_GetItemRef(o, i) __Pyx_XNewRef(PyList_GetItem(o, i)) #endif #else #define __Pyx_PyList_GetItemRef(o, i) __Pyx_NewRef(PyList_GET_ITEM(o, i)) #endif +#if CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS && !CYTHON_COMPILING_IN_LIMITED_API && CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PyList_GetItemRefFast(o, i, unsafe_shared) (__Pyx_IS_UNIQUELY_REFERENCED(o, unsafe_shared) ?\ + __Pyx_NewRef(PyList_GET_ITEM(o, i)) : __Pyx_PyList_GetItemRef(o, i)) +#else + #define __Pyx_PyList_GetItemRefFast(o, i, unsafe_shared) __Pyx_PyList_GetItemRef(o, i) +#endif #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 #define __Pyx_PyDict_GetItemRef(dict, key, result) PyDict_GetItemRef(dict, key, result) #elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS @@ -979,15 +1026,6 @@ static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GetLength(o) #endif -#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 - #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) -#else - static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { - PyObject *module = PyImport_AddModule(name); - Py_XINCREF(module); - return module; - } -#endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_InternFromString) #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif @@ -1094,15 +1132,6 @@ static int __Pyx_init_co_variables(void) { #endif #endif #include -#ifdef NAN -#define __PYX_NAN() ((float) NAN) -#else -static CYTHON_INLINE float __PYX_NAN() { - float value; - memset(&value, 0xFF, sizeof(value)); - return value; -} -#endif #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) #define __Pyx_truncl trunc #else @@ -1143,14 +1172,10 @@ static CYTHON_INLINE float __PYX_NAN() { #define __PYX_HAVE__talib___ta_lib #define __PYX_HAVE_API__talib___ta_lib /* Early includes */ -#if defined(WIN32) || defined(MS_WINDOWS) -#include "ta_libc.h" -#else #include "ta-lib/ta_defs.h" #include "ta-lib/ta_common.h" #include "ta-lib/ta_abstract.h" #include "ta-lib/ta_func.h" -#endif #include #include @@ -1169,6 +1194,15 @@ static CYTHON_INLINE float __PYX_NAN() { #define CYTHON_WITHOUT_ASSERTIONS #endif +#ifdef CYTHON_FREETHREADING_COMPATIBLE +#if CYTHON_FREETHREADING_COMPATIBLE +#define __Pyx_FREETHREADING_COMPATIBLE Py_MOD_GIL_NOT_USED +#else +#define __Pyx_FREETHREADING_COMPATIBLE Py_MOD_GIL_USED +#endif +#else +#define __Pyx_FREETHREADING_COMPATIBLE Py_MOD_GIL_USED +#endif #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 #define __PYX_DEFAULT_STRING_ENCODING "" @@ -1341,7 +1375,9 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #endif /* __GNUC__ */ /* PretendToInitialize */ #ifdef __cplusplus +#if __cplusplus > 201103L #include +#endif template static void __Pyx_pretend_to_initialize(T* ptr) { #if __cplusplus > 201103L @@ -1391,13 +1427,13 @@ static const char* const __pyx_f[] = { "talib/_ta_lib.pyx", "talib/_common.pxi", "talib/_abstract.pxi", - "../../../../private/var/folders/47/nmnxzkvs7vn7147wn2xrcrj80000gn/T/pip-build-env-22rmtgys/overlay/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd", + "../../.cache/uv/builds-v0/.tmpW1VPkd/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd", "talib/_func.pxi", "talib/_stream.pxi", "cpython/type.pxd", }; /* #### Code section: utility_code_proto_before_types ### */ -/* Atomics.proto */ +/* Atomics.proto (used by UnpackUnboundCMethod) */ #include #ifndef CYTHON_ATOMICS #define CYTHON_ATOMICS 1 @@ -1433,6 +1469,7 @@ static const char* const __pyx_f[] = { #define __pyx_atomic_pointer_load_relaxed(value) atomic_load_explicit(value, memory_order_relaxed) #define __pyx_atomic_pointer_load_acquire(value) atomic_load_explicit(value, memory_order_acquire) #define __pyx_atomic_pointer_exchange(value, new_value) atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) + #define __pyx_atomic_pointer_cmp_exchange(value, expected, desired) atomic_compare_exchange_strong(value, expected, desired) #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) #pragma message ("Using standard C atomics") #elif defined(__PYX_DEBUG_ATOMICS) @@ -1457,6 +1494,7 @@ static const char* const __pyx_f[] = { #define __pyx_atomic_pointer_load_relaxed(value) std::atomic_load_explicit(value, std::memory_order_relaxed) #define __pyx_atomic_pointer_load_acquire(value) std::atomic_load_explicit(value, std::memory_order_acquire) #define __pyx_atomic_pointer_exchange(value, new_value) std::atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) + #define __pyx_atomic_pointer_cmp_exchange(value, expected, desired) std::atomic_compare_exchange_strong(value, expected, desired) #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) #pragma message ("Using standard C++ atomics") #elif defined(__PYX_DEBUG_ATOMICS) @@ -1466,6 +1504,7 @@ static const char* const __pyx_f[] = { (__GNUC_MINOR__ > 1 ||\ (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2)))) #define __pyx_atomic_ptr_type void* + #define __pyx_nonatomic_ptr_type void* #define __pyx_atomic_incr_relaxed(value) __sync_fetch_and_add(value, 1) #define __pyx_atomic_incr_acq_rel(value) __sync_fetch_and_add(value, 1) #define __pyx_atomic_decr_acq_rel(value) __sync_fetch_and_sub(value, 1) @@ -1481,6 +1520,12 @@ static const char* const __pyx_f[] = { #define __pyx_atomic_pointer_load_relaxed(value) __sync_fetch_and_add(value, 0) #define __pyx_atomic_pointer_load_acquire(value) __sync_fetch_and_add(value, 0) #define __pyx_atomic_pointer_exchange(value, new_value) __sync_lock_test_and_set(value, (__pyx_atomic_ptr_type)new_value) + static CYTHON_INLINE int __pyx_atomic_pointer_cmp_exchange(__pyx_atomic_ptr_type* value, __pyx_nonatomic_ptr_type* expected, __pyx_nonatomic_ptr_type desired) { + __pyx_nonatomic_ptr_type old = __sync_val_compare_and_swap(value, *expected, desired); + int result = old == *expected; + *expected = old; + return result; + } #ifdef __PYX_DEBUG_ATOMICS #warning "Using GNU atomics" #endif @@ -1491,6 +1536,7 @@ static const char* const __pyx_f[] = { #define __pyx_atomic_ptr_type void* #undef __pyx_nonatomic_int_type #define __pyx_nonatomic_int_type long + #define __pyx_nonatomic_ptr_type void* #pragma intrinsic (_InterlockedExchangeAdd, _InterlockedExchange, _InterlockedCompareExchange, _InterlockedCompareExchangePointer, _InterlockedExchangePointer) #define __pyx_atomic_incr_relaxed(value) _InterlockedExchangeAdd(value, 1) #define __pyx_atomic_incr_acq_rel(value) _InterlockedExchangeAdd(value, 1) @@ -1507,6 +1553,12 @@ static const char* const __pyx_f[] = { #define __pyx_atomic_pointer_load_relaxed(value) *(void * volatile *)value #define __pyx_atomic_pointer_load_acquire(value) _InterlockedCompareExchangePointer(value, 0, 0) #define __pyx_atomic_pointer_exchange(value, new_value) _InterlockedExchangePointer(value, (__pyx_atomic_ptr_type)new_value) + static CYTHON_INLINE int __pyx_atomic_pointer_cmp_exchange(__pyx_atomic_ptr_type* value, __pyx_nonatomic_ptr_type* expected, __pyx_nonatomic_ptr_type desired) { + __pyx_atomic_ptr_type old = _InterlockedCompareExchangePointer(value, desired, *expected); + int result = old == *expected; + *expected = old; + return result; + } #ifdef __PYX_DEBUG_ATOMICS #pragma message ("Using MSVC atomics") #endif @@ -1517,33 +1569,27 @@ static const char* const __pyx_f[] = { #warning "Not using atomics" #endif #endif -#if CYTHON_ATOMICS - #define __pyx_add_acquisition_count(memview)\ - __pyx_atomic_incr_relaxed(__pyx_get_slice_count_pointer(memview)) - #define __pyx_sub_acquisition_count(memview)\ - __pyx_atomic_decr_acq_rel(__pyx_get_slice_count_pointer(memview)) -#else - #define __pyx_add_acquisition_count(memview)\ - __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) - #define __pyx_sub_acquisition_count(memview)\ - __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) -#endif -/* CriticalSections.proto */ +/* CriticalSectionsDefinition.proto (used by CriticalSections) */ #if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING #define __Pyx_PyCriticalSection void* #define __Pyx_PyCriticalSection2 void* -#define __Pyx_PyCriticalSection_Begin1(cs, arg) (void)cs -#define __Pyx_PyCriticalSection_Begin2(cs, arg1, arg2) (void)cs -#define __Pyx_PyCriticalSection_End1(cs) -#define __Pyx_PyCriticalSection_End2(cs) +#define __Pyx_PyCriticalSection_End(cs) +#define __Pyx_PyCriticalSection2_End(cs) #else #define __Pyx_PyCriticalSection PyCriticalSection #define __Pyx_PyCriticalSection2 PyCriticalSection2 -#define __Pyx_PyCriticalSection_Begin1 PyCriticalSection_Begin -#define __Pyx_PyCriticalSection_Begin2 PyCriticalSection2_Begin -#define __Pyx_PyCriticalSection_End1 PyCriticalSection_End -#define __Pyx_PyCriticalSection_End2 PyCriticalSection2_End +#define __Pyx_PyCriticalSection_End PyCriticalSection_End +#define __Pyx_PyCriticalSection2_End PyCriticalSection2_End +#endif + +/* CriticalSections.proto (used by ParseKeywordsImpl) */ +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __Pyx_PyCriticalSection_Begin(cs, arg) (void)(cs) +#define __Pyx_PyCriticalSection2_Begin(cs, arg1, arg2) (void)(cs) +#else +#define __Pyx_PyCriticalSection_Begin PyCriticalSection_Begin +#define __Pyx_PyCriticalSection2_Begin PyCriticalSection2_Begin #endif #if PY_VERSION_HEX < 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_BEGIN_CRITICAL_SECTION(o) { @@ -1553,7 +1599,7 @@ static const char* const __pyx_f[] = { #define __Pyx_END_CRITICAL_SECTION Py_END_CRITICAL_SECTION #endif -/* IncludeStructmemberH.proto */ +/* IncludeStructmemberH.proto (used by FixUpExtensionType) */ #include /* #### Code section: numeric_typedefs ### */ @@ -1707,7 +1753,7 @@ static CYTHON_INLINE __pyx_t_long_double_complex __pyx_t_long_double_complex_fro #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) -/* PyErrExceptionMatches.proto */ +/* PyErrExceptionMatches.proto (used by PyObjectGetAttrStrNoError) */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); @@ -1715,7 +1761,7 @@ static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tsta #define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif -/* PyThreadStateGet.proto */ +/* PyThreadStateGet.proto (used by PyErrFetchRestore) */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; @@ -1733,7 +1779,7 @@ static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tsta #define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() #endif -/* PyErrFetchRestore.proto */ +/* PyErrFetchRestore.proto (used by PyObjectGetAttrStrNoError) */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) #define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) @@ -1758,20 +1804,20 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif -/* PyObjectGetAttrStr.proto */ +/* PyObjectGetAttrStr.proto (used by PyObjectGetAttrStrNoError) */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif -/* PyObjectGetAttrStrNoError.proto */ +/* PyObjectGetAttrStrNoError.proto (used by GetBuiltinName) */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); -/* GetTopmostException.proto */ +/* GetTopmostException.proto (used by SaveResetException) */ #if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif @@ -1795,43 +1841,17 @@ static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif -/* PyFunctionFastCall.proto */ -#if CYTHON_FAST_PYCALL -#if !CYTHON_VECTORCALL -#define __Pyx_PyFunction_FastCall(func, args, nargs)\ - __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) -static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject *const *args, Py_ssize_t nargs, PyObject *kwargs); -#endif -#define __Pyx_BUILD_ASSERT_EXPR(cond)\ - (sizeof(char [1 - 2*!(cond)]) - 1) -#ifndef Py_MEMBER_SIZE -#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) -#endif -#if !CYTHON_VECTORCALL -#if PY_VERSION_HEX >= 0x03080000 - #include "frameobject.h" - #define __Pxy_PyFrame_Initialize_Offsets() - #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) -#else - static size_t __pyx_pyframe_localsplus_offset = 0; - #include "frameobject.h" - #define __Pxy_PyFrame_Initialize_Offsets()\ - ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ - (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) - #define __Pyx_PyFrame_GetLocalsplus(frame)\ - (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) -#endif -#endif -#endif +/* PyImportError_Check.proto */ +#define __Pyx_PyExc_ImportError_Check(obj) __Pyx_TypeCheck(obj, PyExc_ImportError) -/* PyObjectCall.proto */ +/* PyObjectCall.proto (used by PyObjectFastCall) */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); #else #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif -/* PyObjectCallMethO.proto */ +/* PyObjectCallMethO.proto (used by PyObjectFastCall) */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif @@ -1840,24 +1860,45 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject #define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs); -/* RaiseException.proto */ +/* RaiseException.export */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* PyUnicode_Unicode.proto */ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_Unicode(PyObject *obj); -/* PyObjectFormatAndDecref.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f); -static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f); +/* BuildPyUnicode.proto (used by COrdinalToPyUnicode) */ +static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, const char* chars, int clength, + int prepend_sign, char padding_char); + +/* COrdinalToPyUnicode.proto (used by CIntToPyUnicode) */ +static CYTHON_INLINE int __Pyx_CheckUnicodeValue(int value); +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t width, char padding_char); + +/* GCCDiagnostics.proto (used by CIntToPyUnicode) */ +#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif -/* IncludeStringH.proto */ +/* IncludeStdlibH.proto (used by CIntToPyUnicode) */ +#include + +/* IncludeStringH.proto (used by CIntToPyUnicode) */ #include -/* JoinPyUnicode.proto */ +/* CIntToPyUnicode.proto */ +#define __Pyx_PyUnicode_From_TA_RetCode(value, width, padding_char, format_char) (\ + ((format_char) == ('c')) ?\ + __Pyx_uchar___Pyx_PyUnicode_From_TA_RetCode(value, width, padding_char) :\ + __Pyx____Pyx_PyUnicode_From_TA_RetCode(value, width, padding_char, format_char)\ + ) +static CYTHON_INLINE PyObject* __Pyx_uchar___Pyx_PyUnicode_From_TA_RetCode(TA_RetCode value, Py_ssize_t width, char padding_char); +static CYTHON_INLINE PyObject* __Pyx____Pyx_PyUnicode_From_TA_RetCode(TA_RetCode value, Py_ssize_t width, char padding_char, char format_char); + +/* JoinPyUnicode.export */ static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength, Py_UCS4 max_char); -/* TupleAndListFromArray.proto */ +/* TupleAndListFromArray.proto (used by fastcall) */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); #endif @@ -1865,10 +1906,10 @@ static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_s static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); #endif -/* BytesEquals.proto */ +/* BytesEquals.proto (used by UnicodeEquals) */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); -/* UnicodeEquals.proto */ +/* UnicodeEquals.proto (used by fastcall) */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); /* fastcall.proto */ @@ -1907,19 +1948,10 @@ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int #define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) #endif -/* RaiseDoubleKeywords.proto */ -static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); - -/* ParseKeywords.proto */ -static CYTHON_INLINE int __Pyx_ParseKeywords( - PyObject *kwds, PyObject *const *kwvalues, PyObject ** const argnames[], - PyObject *kwds2, PyObject *values[], - Py_ssize_t num_pos_args, Py_ssize_t num_kwargs, - const char* function_name, - int ignore_unknown_kwargs -); +/* py_dict_items.proto (used by OwnedDictNext) */ +static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d); -/* CallCFunction.proto */ +/* CallCFunction.proto (used by CallUnboundCMethod0) */ #define __Pyx_CallCFunction(cfunc, self, args)\ ((PyCFunction)(void(*)(void))(cfunc)->func)(self, args) #define __Pyx_CallCFunctionWithKeywords(cfunc, self, args, kwargs)\ @@ -1929,7 +1961,10 @@ static CYTHON_INLINE int __Pyx_ParseKeywords( #define __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, nargs, kwnames)\ ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs, kwnames) -/* UnpackUnboundCMethod.proto */ +/* PyObjectCallOneArg.proto (used by CallUnboundCMethod0) */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* UnpackUnboundCMethod.proto (used by CallUnboundCMethod0) */ typedef struct { PyObject *type; PyObject **method_name; @@ -1962,6 +1997,59 @@ static CYTHON_INLINE void __Pyx_CachedCFunction_SetFinishedInitializing(__Pyx_Ca #define __Pyx_CachedCFunction_SetFinishedInitializing(cfunc) #endif +/* CallUnboundCMethod0.proto */ +CYTHON_UNUSED +static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self); +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self); +#else +#define __Pyx_CallUnboundCMethod0(cfunc, self) __Pyx__CallUnboundCMethod0(cfunc, self) +#endif + +/* py_dict_values.proto (used by OwnedDictNext) */ +static CYTHON_INLINE PyObject* __Pyx_PyDict_Values(PyObject* d); + +/* OwnedDictNext.proto (used by ParseKeywordsImpl) */ +#if CYTHON_AVOID_BORROWED_REFS +static int __Pyx_PyDict_NextRef(PyObject *p, PyObject **ppos, PyObject **pkey, PyObject **pvalue); +#else +CYTHON_INLINE +static int __Pyx_PyDict_NextRef(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue); +#endif + +/* RaiseDoubleKeywords.proto (used by ParseKeywordsImpl) */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywordsImpl.export */ +static int __Pyx_ParseKeywordsTuple( + PyObject *kwds, + PyObject * const *kwvalues, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs +); +static int __Pyx_ParseKeywordDictToDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name +); +static int __Pyx_ParseKeywordDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs +); + /* CallUnboundCMethod2.proto */ CYTHON_UNUSED static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2); @@ -1971,17 +2059,28 @@ static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction * #define __Pyx_CallUnboundCMethod2(cfunc, self, arg1, arg2) __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2) #endif +/* ParseKeywords.proto */ +static CYTHON_INLINE int __Pyx_ParseKeywords( + PyObject *kwds, PyObject *const *kwvalues, PyObject ** const argnames[], + PyObject *kwds2, PyObject *values[], + Py_ssize_t num_pos_args, Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs +); + /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); +/* ArgTypeTestFunc.export */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); + /* ArgTypeTest.proto */ #define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\ __Pyx__ArgTypeTest(obj, type, name, exact)) -static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); -/* PyDictVersioning.proto */ +/* PyDictVersioning.proto (used by GetModuleGlobalName) */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) #define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) @@ -1992,7 +2091,7 @@ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *nam static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ - (VAR) = __pyx_dict_cached_value;\ + (VAR) = __Pyx_XNewRef(__pyx_dict_cached_value);\ } else {\ (VAR) = __pyx_dict_cached_value = (LOOKUP);\ __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ @@ -2028,7 +2127,7 @@ static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_ve static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif -/* PyObjectDelAttr.proto */ +/* PyObjectDelAttr.proto (used by PyObjectSetAttrStr) */ #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 #define __Pyx_PyObject_DelAttr(o, n) PyObject_SetAttr(o, n, NULL) #else @@ -2045,29 +2144,26 @@ static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr #endif /* GetItemInt.proto */ -#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil, unsafe_shared)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck, unsafe_shared) :\ (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ __Pyx_GetItemInt_Generic(o, to_py_func(i)))) -#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil, unsafe_shared)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck, unsafe_shared) :\ (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, - int wraparound, int boundscheck); -#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + int wraparound, int boundscheck, int unsafe_shared); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil, unsafe_shared)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck, unsafe_shared) :\ (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, - int wraparound, int boundscheck); + int wraparound, int boundscheck, int unsafe_shared); static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, - int is_list, int wraparound, int boundscheck); - -/* PyObjectCallOneArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + int is_list, int wraparound, int boundscheck, int unsafe_shared); /* ObjectGetItem.proto */ #if CYTHON_USE_TYPE_SLOTS @@ -2090,6 +2186,11 @@ static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const * static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); #endif +/* PyRange_Check.proto */ +#if CYTHON_COMPILING_IN_PYPY && !defined(PyRange_Check) + #define PyRange_Check(obj) __Pyx_TypeCheck((obj), &PyRange_Type) +#endif + /* DictGetItem.proto */ #if !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); @@ -2140,22 +2241,24 @@ static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { #define __Pyx_PyList_Append(L,x) PyList_Append(L,x) #endif -/* PyObjectCallNoArg.proto */ +/* PyObjectCallNoArg.proto (used by PyObjectCallMethod0) */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); -/* PyObjectGetMethod.proto */ +/* PyObjectGetMethod.proto (used by PyObjectCallMethod0) */ +#if !(CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000))) static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); +#endif -/* PyObjectCallMethod0.proto */ +/* PyObjectCallMethod0.proto (used by dict_iter) */ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); -/* RaiseNoneIterError.proto */ +/* RaiseNoneIterError.proto (used by UnpackTupleError) */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); -/* UnpackTupleError.proto */ +/* UnpackTupleError.proto (used by UnpackTuple2) */ static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); -/* UnpackTuple2.proto */ +/* UnpackTuple2.proto (used by dict_iter) */ static CYTHON_INLINE int __Pyx_unpack_tuple2( PyObject* tuple, PyObject** value1, PyObject** value2, int is_tuple, int has_known_size, int decref_tuple); static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( @@ -2216,24 +2319,20 @@ static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { #define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) #endif -/* BuildPyUnicode.proto */ -static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, const char* chars, int clength, - int prepend_sign, char padding_char); - -/* COrdinalToPyUnicode.proto */ -static CYTHON_INLINE int __Pyx_CheckUnicodeValue(int value); -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t width, char padding_char); - -/* GCCDiagnostics.proto */ -#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) -#define __Pyx_HAS_GCC_DIAGNOSTIC -#endif - -/* IncludeStdlibH.proto */ -#include +/* PyIndexError_Check.proto */ +#define __Pyx_PyExc_IndexError_Check(obj) __Pyx_TypeCheck(obj, PyExc_IndexError) /* CIntToPyUnicode.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char); +#define __Pyx_PyUnicode_From_Py_ssize_t(value, width, padding_char, format_char) (\ + ((format_char) == ('c')) ?\ + __Pyx_uchar___Pyx_PyUnicode_From_Py_ssize_t(value, width, padding_char) :\ + __Pyx____Pyx_PyUnicode_From_Py_ssize_t(value, width, padding_char, format_char)\ + ) +static CYTHON_INLINE PyObject* __Pyx_uchar___Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char); +static CYTHON_INLINE PyObject* __Pyx____Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char); + +/* PyTypeError_Check.proto */ +#define __Pyx_PyExc_TypeError_Check(obj) __Pyx_TypeCheck(obj, PyExc_TypeError) /* SliceTupleAndList.proto */ #if CYTHON_COMPILING_IN_CPYTHON @@ -2244,6 +2343,10 @@ static CYTHON_INLINE PyObject* __Pyx_PyTuple_GetSlice(PyObject* src, Py_ssize_t #define __Pyx_PyTuple_GetSlice(seq, start, stop) PySequence_GetSlice(seq, start, stop) #endif +/* PyObjectFormatAndDecref.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f); +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f); + /* PyObject_Unicode.proto */ #define __Pyx_PyObject_Unicode(obj)\ (likely(PyUnicode_CheckExact(obj)) ? __Pyx_NewRef(obj) : PyObject_Str(obj)) @@ -2251,17 +2354,8 @@ static CYTHON_INLINE PyObject* __Pyx_PyTuple_GetSlice(PyObject* src, Py_ssize_t /* py_dict_keys.proto */ static CYTHON_INLINE PyObject* __Pyx_PyDict_Keys(PyObject* d); -/* CallUnboundCMethod0.proto */ -CYTHON_UNUSED -static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self); -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self); -#else -#define __Pyx_CallUnboundCMethod0(cfunc, self) __Pyx__CallUnboundCMethod0(cfunc, self) -#endif - -/* RaiseUnexpectedTypeError.proto */ -static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); +/* pyint_simplify.proto */ +static CYTHON_INLINE int __Pyx_PyInt_FromNumber(PyObject **number_var, const char *argname, int accept_none); /* SliceObject.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice( @@ -2269,66 +2363,84 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice( PyObject** py_start, PyObject** py_stop, PyObject** py_slice, int has_cstart, int has_cstop, int wraparound); -/* ModFloat[double].proto */ -static CYTHON_INLINE double __Pyx_mod_double(double, double, int b_is_constant); - /* SetItemInt.proto */ -#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ +#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil, unsafe_shared)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\ + __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck, unsafe_shared) :\ (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\ __Pyx_SetItemInt_Generic(o, to_py_func(i), v))) static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, - int is_list, int wraparound, int boundscheck); + int is_list, int wraparound, int boundscheck, int unsafe_shared); /* TypeImport.proto */ -#ifndef __PYX_HAVE_RT_ImportType_proto_3_1_1 -#define __PYX_HAVE_RT_ImportType_proto_3_1_1 +#ifndef __PYX_HAVE_RT_ImportType_proto_3_2_8 +#define __PYX_HAVE_RT_ImportType_proto_3_2_8 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L #include #endif #if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L -#define __PYX_GET_STRUCT_ALIGNMENT_3_1_1(s) alignof(s) +#define __PYX_GET_STRUCT_ALIGNMENT_3_2_8(s) alignof(s) #else -#define __PYX_GET_STRUCT_ALIGNMENT_3_1_1(s) sizeof(void*) +#define __PYX_GET_STRUCT_ALIGNMENT_3_2_8(s) sizeof(void*) #endif -enum __Pyx_ImportType_CheckSize_3_1_1 { - __Pyx_ImportType_CheckSize_Error_3_1_1 = 0, - __Pyx_ImportType_CheckSize_Warn_3_1_1 = 1, - __Pyx_ImportType_CheckSize_Ignore_3_1_1 = 2 +enum __Pyx_ImportType_CheckSize_3_2_8 { + __Pyx_ImportType_CheckSize_Error_3_2_8 = 0, + __Pyx_ImportType_CheckSize_Warn_3_2_8 = 1, + __Pyx_ImportType_CheckSize_Ignore_3_2_8 = 2 }; -static PyTypeObject *__Pyx_ImportType_3_1_1(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_1_1 check_size); +static PyTypeObject *__Pyx_ImportType_3_2_8(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_2_8 check_size); #endif -/* FixUpExtensionType.proto */ +/* dict_setdefault.proto (used by FetchCommonType) */ +static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value); + +/* LimitedApiGetTypeDict.proto (used by SetItemOnTypeDict) */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp); +#endif + +/* SetItemOnTypeDict.proto (used by FixUpExtensionType) */ +static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v); +#define __Pyx_SetItemOnTypeDict(tp, k, v) __Pyx__SetItemOnTypeDict((PyTypeObject*)tp, k, v) + +/* FixUpExtensionType.proto (used by FetchCommonType) */ static CYTHON_INLINE int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); -/* FetchSharedCythonModule.proto */ +/* AddModuleRef.proto (used by FetchSharedCythonModule) */ +#if ((CYTHON_COMPILING_IN_CPYTHON_FREETHREADING ) ||\ + __PYX_LIMITED_VERSION_HEX < 0x030d0000) + static PyObject *__Pyx_PyImport_AddModuleRef(const char *name); +#else + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#endif + +/* FetchSharedCythonModule.proto (used by FetchCommonType) */ static PyObject *__Pyx_FetchSharedCythonABIModule(void); -/* dict_setdefault.proto */ -static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value, int is_safe_type); +/* FetchCommonType.proto (used by CommonTypesMetaclass) */ +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases); -/* FetchCommonType.proto */ -static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); +/* CommonTypesMetaclass.proto (used by CythonFunctionShared) */ +static int __pyx_CommonTypesMetaclass_init(PyObject *module); +#define __Pyx_CommonTypesMetaclass_USED -/* CallTypeTraverse.proto */ +/* CallTypeTraverse.proto (used by CythonFunctionShared) */ #if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) #define __Pyx_call_type_traverse(o, always_call, visit, arg) 0 #else static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg); #endif -/* PyMethodNew.proto */ +/* PyMethodNew.proto (used by CythonFunctionShared) */ static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ); -/* PyVectorcallFastCallDict.proto */ -#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) +/* PyVectorcallFastCallDict.proto (used by CythonFunctionShared) */ +#if CYTHON_METH_FASTCALL && CYTHON_VECTORCALL static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); #endif -/* CythonFunctionShared.proto */ +/* CythonFunctionShared.proto (used by CythonFunction) */ #define __Pyx_CyFunction_USED #define __Pyx_CYFUNCTION_STATICMETHOD 0x01 #define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 @@ -2358,14 +2470,15 @@ typedef struct { #else PyCMethodObject func; #endif -#if CYTHON_BACKPORT_VECTORCALL ||\ - (CYTHON_COMPILING_IN_LIMITED_API && CYTHON_METH_FASTCALL) +#if CYTHON_COMPILING_IN_LIMITED_API && CYTHON_METH_FASTCALL __pyx_vectorcallfunc func_vectorcall; #endif #if CYTHON_COMPILING_IN_LIMITED_API PyObject *func_weakreflist; #endif +#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API PyObject *func_dict; +#endif PyObject *func_name; PyObject *func_qualname; PyObject *func_doc; @@ -2410,7 +2523,7 @@ static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *c static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -#if CYTHON_BACKPORT_VECTORCALL || CYTHON_COMPILING_IN_LIMITED_API +#if CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) #else #define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) @@ -2441,10 +2554,10 @@ static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bas #define __Pyx_SetNameInClass(ns, name, value) PyObject_SetItem(ns, name, value) #endif -/* PyObjectCall2Args.proto */ +/* PyObjectCall2Args.proto (used by Py3ClassCreate) */ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); -/* PyObjectLookupSpecial.proto */ +/* PyObjectLookupSpecial.proto (used by Py3ClassCreate) */ #if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS #define __Pyx_PyObject_LookupSpecialNoError(obj, attr_name) __Pyx__PyObject_LookupSpecial(obj, attr_name, 0) #define __Pyx_PyObject_LookupSpecial(obj, attr_name) __Pyx__PyObject_LookupSpecial(obj, attr_name, 1) @@ -2463,33 +2576,35 @@ static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObj /* ListPack.proto */ static PyObject *__Pyx_PyList_Pack(Py_ssize_t n, ...); +/* ImportImpl.export */ +static PyObject *__Pyx__Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, PyObject *moddict, int level); + /* Import.proto */ -static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); +static CYTHON_INLINE PyObject *__Pyx_Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, int level); /* ImportFrom.proto */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); -/* ImportDottedModule.proto */ -static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple); -static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple); - -/* ImportDottedModuleRelFirst.proto */ -static PyObject *__Pyx_ImportDottedModuleRelFirst(PyObject *name, PyObject *parts_tuple); - -/* PyObjectCallMethod1.proto */ +/* PyObjectCallMethod1.proto (used by append) */ static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); /* append.proto */ static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x); -/* CLineInTraceback.proto */ +/* PyModuleNotFoundError_Check.proto */ +#define __Pyx_PyExc_ModuleNotFoundError_Check(obj) __Pyx_TypeCheck(obj, PyExc_ModuleNotFoundError) + +/* PyNameError_Check.proto */ +#define __Pyx_PyExc_NameError_Check(obj) __Pyx_TypeCheck(obj, PyExc_NameError) + +/* CLineInTraceback.proto (used by AddTraceback) */ #if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #else #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #endif -/* CodeObjectCache.proto */ +/* CodeObjectCache.proto (used by AddTraceback) */ #if CYTHON_COMPILING_IN_LIMITED_API typedef PyObject __Pyx_CachedCodeObjectType; #else @@ -2660,9 +2775,6 @@ static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value); -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_RetCode(TA_RetCode value); - /* CIntFromPy.proto */ static CYTHON_INLINE TA_FuncUnstId __Pyx_PyLong_As_TA_FuncUnstId(PyObject *); @@ -2741,11 +2853,20 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj #endif /* GetRuntimeVersion.proto */ +#if __PYX_LIMITED_VERSION_HEX < 0x030b0000 +static unsigned long __Pyx_cached_runtime_version = 0; +static void __Pyx_init_runtime_version(void); +#else +#define __Pyx_init_runtime_version() +#endif static unsigned long __Pyx_get_runtime_version(void); /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); +/* DecompressString.proto */ +static PyObject *__Pyx_DecompressString(const char *s, Py_ssize_t length, int algo); + /* MultiPhaseInitModuleState.proto */ #if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE static PyObject *__Pyx_State_FindModule(void*); @@ -2793,6 +2914,11 @@ static int __Pyx_State_RemoveModule(void*); #define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI #define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." +static CYTHON_INLINE PyTypeObject *__pyx_f_5numpy_5dtype_7typeobj_typeobj(PyArray_Descr *__pyx_v_self); /* proto*/ +static CYTHON_INLINE char __pyx_f_5numpy_5dtype_4kind_kind(PyArray_Descr *__pyx_v_self); /* proto*/ +static CYTHON_INLINE char __pyx_f_5numpy_5dtype_4type_type(PyArray_Descr *__pyx_v_self); /* proto*/ +static CYTHON_INLINE char __pyx_f_5numpy_5dtype_9byteorder_byteorder(PyArray_Descr *__pyx_v_self); /* proto*/ +static CYTHON_INLINE int __pyx_f_5numpy_5dtype_8type_num_type_num(PyArray_Descr *__pyx_v_self); /* proto*/ static CYTHON_INLINE npy_intp __pyx_f_5numpy_5dtype_8itemsize_itemsize(PyArray_Descr *__pyx_v_self); /* proto*/ static CYTHON_INLINE npy_intp __pyx_f_5numpy_5dtype_9alignment_alignment(PyArray_Descr *__pyx_v_self); /* proto*/ static CYTHON_INLINE PyObject *__pyx_f_5numpy_5dtype_6fields_fields(PyArray_Descr *__pyx_v_self); /* proto*/ @@ -2812,6 +2938,17 @@ static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_5shape_shape(PyArrayObjec static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_7strides_strides(PyArrayObject *__pyx_v_self); /* proto*/ static CYTHON_INLINE npy_intp __pyx_f_5numpy_7ndarray_4size_size(PyArrayObject *__pyx_v_self); /* proto*/ static CYTHON_INLINE char *__pyx_f_5numpy_7ndarray_4data_data(PyArrayObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE int __pyx_f_5numpy_5ufunc_3nin_nin(PyUFuncObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE int __pyx_f_5numpy_5ufunc_4nout_nout(PyUFuncObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE int __pyx_f_5numpy_5ufunc_5nargs_nargs(PyUFuncObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE PyUFuncGenericFunction *__pyx_f_5numpy_5ufunc_9functions_functions(PyUFuncObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE void **__pyx_f_5numpy_5ufunc_4data_data(PyUFuncObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE int __pyx_f_5numpy_5ufunc_6ntypes_ntypes(PyUFuncObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE char const *__pyx_f_5numpy_5ufunc_4name_name(PyUFuncObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE char const *__pyx_f_5numpy_5ufunc_3doc_doc(PyUFuncObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE void *__pyx_f_5numpy_5ufunc_3ptr_ptr(PyUFuncObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_5numpy_5ufunc_3obj_obj(PyUFuncObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_5numpy_5ufunc_9userloops_userloops(PyUFuncObject *__pyx_v_self); /* proto*/ /* Module declarations from "libc.string" */ @@ -2860,1168 +2997,11 @@ int __pyx_module_is_main_talib___ta_lib = 0; /* Implementation of "talib._ta_lib" */ /* #### Code section: global_var ### */ static PyObject *__pyx_builtin_object; -static PyObject *__pyx_builtin_range; static PyObject *__pyx_builtin_enumerate; -static PyObject *__pyx_builtin_ImportError; -static PyObject *__pyx_builtin_ModuleNotFoundError; -static PyObject *__pyx_builtin_NameError; static PyObject *__pyx_builtin_property; -static PyObject *__pyx_builtin_xrange; -static PyObject *__pyx_builtin_IndexError; -static PyObject *__pyx_builtin_TypeError; static PyObject *__pyx_builtin_min; static PyObject *__pyx_builtin_max; /* #### Code section: string_decls ### */ -static const char __pyx_k_[] = ": "; -static const char __pyx_k_3[] = "3"; -static const char __pyx_k_b[] = "b"; -static const char __pyx_k_d[] = "d"; -static const char __pyx_k_i[] = "i"; -static const char __pyx_k_n[] = "n"; -static const char __pyx_k_s[] = "s"; -static const char __pyx_k_AD[] = "AD"; -static const char __pyx_k_DX[] = "DX"; -static const char __pyx_k_LN[] = "LN"; -static const char __pyx_k_MA[] = "MA"; -static const char __pyx_k_T3[] = "T3"; -static const char __pyx_k__2[] = ""; -static const char __pyx_k__3[] = ", "; -static const char __pyx_k__4[] = " ("; -static const char __pyx_k__5[] = ")"; -static const char __pyx_k__6[] = "("; -static const char __pyx_k__7[] = " "; -static const char __pyx_k__8[] = "["; -static const char __pyx_k__9[] = "="; -static const char __pyx_k_id[] = "id"; -static const char __pyx_k_in[] = "in"; -static const char __pyx_k_1_1[] = "\200\001\340\004\017\320\017#\2401\330\004\013\2101"; -static const char __pyx_k_ADD[] = "ADD"; -static const char __pyx_k_ADX[] = "ADX"; -static const char __pyx_k_ALL[] = "ALL"; -static const char __pyx_k_APO[] = "APO"; -static const char __pyx_k_ATR[] = "ATR"; -static const char __pyx_k_A_q[] = "\200A\330\010\017\210q"; -static const char __pyx_k_BOP[] = "BOP"; -static const char __pyx_k_CCI[] = "CCI"; -static const char __pyx_k_CMO[] = "CMO"; -static const char __pyx_k_COS[] = "COS"; -static const char __pyx_k_DIV[] = "DIV"; -static const char __pyx_k_Dot[] = "Dot"; -static const char __pyx_k_EMA[] = "EMA"; -static const char __pyx_k_EXP[] = "EXP"; -static const char __pyx_k_Far[] = "Far"; -static const char __pyx_k_IMI[] = "IMI"; -static const char __pyx_k_MAX[] = "MAX"; -static const char __pyx_k_MFI[] = "MFI"; -static const char __pyx_k_MIN[] = "MIN"; -static const char __pyx_k_MOM[] = "MOM"; -static const char __pyx_k_OBV[] = "OBV"; -static const char __pyx_k_PPO[] = "PPO"; -static const char __pyx_k_Q_q[] = "\200\001\340\004\022\220.\240\001\330\004\025\220Q\320\026'\240q"; -static const char __pyx_k_ROC[] = "ROC"; -static const char __pyx_k_RSI[] = "RSI"; -static const char __pyx_k_SAR[] = "SAR"; -static const char __pyx_k_SIN[] = "SIN"; -static const char __pyx_k_SMA[] = "SMA"; -static const char __pyx_k_SUB[] = "SUB"; -static const char __pyx_k_SUM[] = "SUM"; -static const char __pyx_k_TAN[] = "TAN"; -static const char __pyx_k_TSF[] = "TSF"; -static const char __pyx_k_VAR[] = "VAR"; -static const char __pyx_k_WMA[] = "WMA"; -static const char __pyx_k__10[] = "]"; -static const char __pyx_k__11[] = " "; -static const char __pyx_k__12[] = ")\n"; -static const char __pyx_k__13[] = "\n"; -static const char __pyx_k__14[] = "."; -static const char __pyx_k__15[] = "?"; -static const char __pyx_k_all[] = "__all__"; -static const char __pyx_k_arg[] = "arg"; -static const char __pyx_k_doc[] = "__doc__"; -static const char __pyx_k_got[] = ", got "; -static const char __pyx_k_idx[] = "idx"; -static const char __pyx_k_key[] = "key"; -static const char __pyx_k_log[] = "log"; -static const char __pyx_k_low[] = "low"; -static const char __pyx_k_max[] = "max"; -static const char __pyx_k_min[] = "min"; -static const char __pyx_k_msg[] = "msg"; -static const char __pyx_k_nan[] = "nan"; -static const char __pyx_k_out[] = "out"; -static const char __pyx_k_pop[] = "pop"; -static const char __pyx_k_ret[] = "ret"; -static const char __pyx_k_run[] = "run"; -static const char __pyx_k_s_2[] = "%s"; -static const char __pyx_k_s_3[] = "(%s)"; -static const char __pyx_k_s_4[] = " %s"; -static const char __pyx_k_str[] = "__str__"; -static const char __pyx_k_sys[] = "sys"; -static const char __pyx_k_ACOS[] = "ACOS"; -static const char __pyx_k_ADXR[] = "ADXR"; -static const char __pyx_k_ASIN[] = "ASIN"; -static const char __pyx_k_ATAN[] = "ATAN"; -static const char __pyx_k_A_Qd[] = "\200A\330\010\017\320\017%\240Q\240d\250&\260\001\260\021"; -static const char __pyx_k_BETA[] = "BETA"; -static const char __pyx_k_CEIL[] = "CEIL"; -static const char __pyx_k_COSH[] = "COSH"; -static const char __pyx_k_DEMA[] = "DEMA"; -static const char __pyx_k_KAMA[] = "KAMA"; -static const char __pyx_k_Line[] = "Line"; -static const char __pyx_k_MACD[] = "MACD"; -static const char __pyx_k_MAMA[] = "MAMA"; -static const char __pyx_k_MAVP[] = "MAVP"; -static const char __pyx_k_MULT[] = "MULT"; -static const char __pyx_k_NATR[] = "NATR"; -static const char __pyx_k_NONE[] = "NONE"; -static const char __pyx_k_Near[] = "Near"; -static const char __pyx_k_None[] = "None"; -static const char __pyx_k_ROCP[] = "ROCP"; -static const char __pyx_k_ROCR[] = "ROCR"; -static const char __pyx_k_SINH[] = "SINH"; -static const char __pyx_k_SQRT[] = "SQRT"; -static const char __pyx_k_TANH[] = "TANH"; -static const char __pyx_k_TEMA[] = "TEMA"; -static const char __pyx_k_TRIX[] = "TRIX"; -static const char __pyx_k_args[] = "args"; -static const char __pyx_k_call[] = "__call__"; -static const char __pyx_k_copy[] = "copy"; -static const char __pyx_k_docs[] = "docs"; -static const char __pyx_k_flag[] = "flag"; -static const char __pyx_k_func[] = "__func__"; -static const char __pyx_k_help[] = "help"; -static const char __pyx_k_high[] = "high"; -static const char __pyx_k_info[] = "info"; -static const char __pyx_k_init[] = "__init__"; -static const char __pyx_k_keys[] = "keys"; -static const char __pyx_k_main[] = "__main__"; -static const char __pyx_k_math[] = "math"; -static const char __pyx_k_name[] = "name"; -static const char __pyx_k_open[] = "open"; -static const char __pyx_k_real[] = "real"; -static const char __pyx_k_repr[] = "__repr__"; -static const char __pyx_k_self[] = "self"; -static const char __pyx_k_spec[] = "__spec__"; -static const char __pyx_k_test[] = "__test__"; -static const char __pyx_k_type[] = "type_"; -static const char __pyx_k_ADOSC[] = "ADOSC"; -static const char __pyx_k_AROON[] = "AROON"; -static const char __pyx_k_A_q_q[] = "\200A\330\010\017\210q\220\007\220q\230\001"; -static const char __pyx_k_A_t85[] = "\200A\360\n\000\t\020\210t\2208\2305\240\001\240\021"; -static const char __pyx_k_A_uAS[] = "\200A\330\010\017\210u\220A\220S\230\001"; -static const char __pyx_k_A_uBd[] = "\200A\330\010\017\210u\220B\220d\230!"; -static const char __pyx_k_Equal[] = "Equal"; -static const char __pyx_k_FLOOR[] = "FLOOR"; -static const char __pyx_k_LOG10[] = "LOG10"; -static const char __pyx_k_STOCH[] = "STOCH"; -static const char __pyx_k_TA_AD[] = "TA_AD"; -static const char __pyx_k_TA_DX[] = "TA_DX"; -static const char __pyx_k_TA_LN[] = "TA_LN"; -static const char __pyx_k_TA_MA[] = "TA_MA"; -static const char __pyx_k_TA_T3[] = "TA_T3"; -static const char __pyx_k_TRIMA[] = "TRIMA"; -static const char __pyx_k_WILLR[] = "WILLR"; -static const char __pyx_k_a_QoQ[] = "\200\001\340\004\022\220,\230a\330\004\025\220Q\220o\240Q"; -static const char __pyx_k_ascii[] = "ascii"; -static const char __pyx_k_clone[] = "clone"; -static const char __pyx_k_close[] = "close"; -static const char __pyx_k_empty[] = "empty"; -static const char __pyx_k_flags[] = "flags"; -static const char __pyx_k_group[] = "group"; -static const char __pyx_k_index[] = "index"; -static const char __pyx_k_items[] = "items"; -static const char __pyx_k_local[] = "local"; -static const char __pyx_k_lower[] = "lower"; -static const char __pyx_k_nbdev[] = "nbdev"; -static const char __pyx_k_numpy[] = "numpy"; -static const char __pyx_k_optIn[] = "optIn"; -static const char __pyx_k_param[] = "param"; -static const char __pyx_k_price[] = "price"; -static const char __pyx_k_range[] = "range"; -static const char __pyx_k_real0[] = "real0"; -static const char __pyx_k_real1[] = "real1"; -static const char __pyx_k_table[] = "table"; -static const char __pyx_k_upper[] = "upper"; -static const char __pyx_k_value[] = "value"; -static const char __pyx_k_AVGDEV[] = "AVGDEV"; -static const char __pyx_k_A_t81A[] = "\200A\330\010\017\210t\2208\2301\230A"; -static const char __pyx_k_BBANDS[] = "BBANDS"; -static const char __pyx_k_CORREL[] = "CORREL"; -static const char __pyx_k_Inputs[] = "Inputs:"; -static const char __pyx_k_MINMAX[] = "MINMAX"; -static const char __pyx_k_SAREXT[] = "SAREXT"; -static const char __pyx_k_STDDEV[] = "STDDEV"; -static const char __pyx_k_STOCHF[] = "STOCHF"; -static const char __pyx_k_Series[] = "Series"; -static const char __pyx_k_TA_ADD[] = "TA_ADD"; -static const char __pyx_k_TA_ADX[] = "TA_ADX"; -static const char __pyx_k_TA_APO[] = "TA_APO"; -static const char __pyx_k_TA_ATR[] = "TA_ATR"; -static const char __pyx_k_TA_BOP[] = "TA_BOP"; -static const char __pyx_k_TA_CCI[] = "TA_CCI"; -static const char __pyx_k_TA_CMO[] = "TA_CMO"; -static const char __pyx_k_TA_COS[] = "TA_COS"; -static const char __pyx_k_TA_DIV[] = "TA_DIV"; -static const char __pyx_k_TA_EMA[] = "TA_EMA"; -static const char __pyx_k_TA_EXP[] = "TA_EXP"; -static const char __pyx_k_TA_IMI[] = "TA_IMI"; -static const char __pyx_k_TA_MAX[] = "TA_MAX"; -static const char __pyx_k_TA_MFI[] = "TA_MFI"; -static const char __pyx_k_TA_MIN[] = "TA_MIN"; -static const char __pyx_k_TA_MOM[] = "TA_MOM"; -static const char __pyx_k_TA_OBV[] = "TA_OBV"; -static const char __pyx_k_TA_PPO[] = "TA_PPO"; -static const char __pyx_k_TA_ROC[] = "TA_ROC"; -static const char __pyx_k_TA_RSI[] = "TA_RSI"; -static const char __pyx_k_TA_SAR[] = "TA_SAR"; -static const char __pyx_k_TA_SIN[] = "TA_SIN"; -static const char __pyx_k_TA_SMA[] = "TA_SMA"; -static const char __pyx_k_TA_SUB[] = "TA_SUB"; -static const char __pyx_k_TA_SUM[] = "TA_SUM"; -static const char __pyx_k_TA_TAN[] = "TA_TAN"; -static const char __pyx_k_TA_TSF[] = "TA_TSF"; -static const char __pyx_k_TA_VAR[] = "TA_VAR"; -static const char __pyx_k_TA_WMA[] = "TA_WMA"; -static const char __pyx_k_TRANGE[] = "TRANGE"; -static const char __pyx_k_ULTOSC[] = "ULTOSC"; -static const char __pyx_k_append[] = "append"; -static const char __pyx_k_aq_Q_Q[] = "\200\001\340\004\022\320\022&\240a\240q\330\004\025\220Q\320\026-\250Q"; -static const char __pyx_k_astype[] = "astype"; -static const char __pyx_k_begidx[] = "begidx"; -static const char __pyx_k_decode[] = "decode"; -static const char __pyx_k_endidx[] = "endidx"; -static const char __pyx_k_factor[] = "factor"; -static const char __pyx_k_groups[] = "groups"; -static const char __pyx_k_holder[] = "holder"; -static const char __pyx_k_kwargs[] = "kwargs"; -static const char __pyx_k_length[] = "length"; -static const char __pyx_k_lookup[] = "_lookup"; -static const char __pyx_k_matype[] = "matype"; -static const char __pyx_k_module[] = "__module__"; -static const char __pyx_k_name_2[] = "__name__"; -static const char __pyx_k_object[] = "object"; -static const char __pyx_k_outmax[] = "outmax"; -static const char __pyx_k_outmin[] = "outmin"; -static const char __pyx_k_output[] = "output"; -static const char __pyx_k_pandas[] = "pandas"; -static const char __pyx_k_params[] = "params"; -static const char __pyx_k_period[] = "period"; -static const char __pyx_k_polars[] = "polars"; -static const char __pyx_k_price0[] = "price0"; -static const char __pyx_k_price1[] = "price1"; -static const char __pyx_k_prices[] = "prices"; -static const char __pyx_k_schema[] = "schema"; -static const char __pyx_k_series[] = "series"; -static const char __pyx_k_type_2[] = "type"; -static const char __pyx_k_update[] = "update"; -static const char __pyx_k_values[] = "values"; -static const char __pyx_k_volume[] = "volume"; -static const char __pyx_k_2_1_Q_9[] = "\200\001\340\004\022\320\0222\260!\2601\330\004\025\220Q\320\0269\270\021"; -static const char __pyx_k_A_t85_Q[] = "\200A\360\n\000\t\020\210t\2208\2305\240\005\240Q"; -static const char __pyx_k_A_wat81[] = "\200A\330\010\017\210w\220a\220t\2308\2401"; -static const char __pyx_k_CDLDOJI[] = "CDLDOJI"; -static const char __pyx_k_HT_SINE[] = "HT_SINE"; -static const char __pyx_k_HighLow[] = "HighLow"; -static const char __pyx_k_MACDEXT[] = "MACDEXT"; -static const char __pyx_k_MACDFIX[] = "MACDFIX"; -static const char __pyx_k_MA_Type[] = "MA_Type"; -static const char __pyx_k_Outputs[] = "Outputs:"; -static const char __pyx_k_PLUS_DI[] = "PLUS_DI"; -static const char __pyx_k_PLUS_DM[] = "PLUS_DM"; -static const char __pyx_k_Qa_Qa_1[] = "\200\001\340\004\034\320\034-\250Q\250a\330\004\020\320\020%\240Q\240a\330\004\013\2101"; -static const char __pyx_k_ROCR100[] = "ROCR100"; -static const char __pyx_k_Shadows[] = "Shadows"; -static const char __pyx_k_TA_ACOS[] = "TA_ACOS"; -static const char __pyx_k_TA_ADXR[] = "TA_ADXR"; -static const char __pyx_k_TA_ASIN[] = "TA_ASIN"; -static const char __pyx_k_TA_ATAN[] = "TA_ATAN"; -static const char __pyx_k_TA_BETA[] = "TA_BETA"; -static const char __pyx_k_TA_CEIL[] = "TA_CEIL"; -static const char __pyx_k_TA_COSH[] = "TA_COSH"; -static const char __pyx_k_TA_DEMA[] = "TA_DEMA"; -static const char __pyx_k_TA_KAMA[] = "TA_KAMA"; -static const char __pyx_k_TA_MACD[] = "TA_MACD"; -static const char __pyx_k_TA_MAMA[] = "TA_MAMA"; -static const char __pyx_k_TA_MAVP[] = "TA_MAVP"; -static const char __pyx_k_TA_MULT[] = "TA_MULT"; -static const char __pyx_k_TA_NATR[] = "TA_NATR"; -static const char __pyx_k_TA_ROCP[] = "TA_ROCP"; -static const char __pyx_k_TA_ROCR[] = "TA_ROCR"; -static const char __pyx_k_TA_SINH[] = "TA_SINH"; -static const char __pyx_k_TA_SQRT[] = "TA_SQRT"; -static const char __pyx_k_TA_TANH[] = "TA_TANH"; -static const char __pyx_k_TA_TEMA[] = "TA_TEMA"; -static const char __pyx_k_TA_TRIX[] = "TA_TRIX"; -static const char __pyx_k_columns[] = "columns"; -static const char __pyx_k_getitem[] = "__getitem__"; -static const char __pyx_k_integer[] = "integer"; -static const char __pyx_k_local_2[] = "__local"; -static const char __pyx_k_max_int[] = "max_int"; -static const char __pyx_k_maximum[] = "maximum"; -static const char __pyx_k_min_int[] = "min_int"; -static const char __pyx_k_missing[] = "missing"; -static const char __pyx_k_nbdevdn[] = "nbdevdn"; -static const char __pyx_k_nbdevup[] = "nbdevup"; -static const char __pyx_k_outfama[] = "outfama"; -static const char __pyx_k_outmacd[] = "outmacd"; -static const char __pyx_k_outmama[] = "outmama"; -static const char __pyx_k_outputs[] = "outputs"; -static const char __pyx_k_outreal[] = "outreal"; -static const char __pyx_k_outsine[] = "outsine"; -static const char __pyx_k_periods[] = "periods"; -static const char __pyx_k_prepare[] = "__prepare__"; -static const char __pyx_k_q_1_Q_a[] = "\200\001\340\004\022\320\022'\240q\250\r\260[\300\013\3101\330\004\025\220Q\320\026.\250a"; -static const char __pyx_k_replace[] = "replace"; -static const char __pyx_k_results[] = "results"; -static const char __pyx_k_retCode[] = "retCode"; -static const char __pyx_k_unicode[] = "__unicode__"; -static const char __pyx_k_version[] = "version"; -static const char __pyx_k_vfactor[] = "vfactor"; -static const char __pyx_k_ACCBANDS[] = "ACCBANDS"; -static const char __pyx_k_AROONOSC[] = "AROONOSC"; -static const char __pyx_k_AVGPRICE[] = "AVGPRICE"; -static const char __pyx_k_BodyDoji[] = "BodyDoji"; -static const char __pyx_k_BodyLong[] = "BodyLong"; -static const char __pyx_k_Function[] = "Function"; -static const char __pyx_k_MAXINDEX[] = "MAXINDEX"; -static const char __pyx_k_MEDPRICE[] = "MEDPRICE"; -static const char __pyx_k_MIDPOINT[] = "MIDPOINT"; -static const char __pyx_k_MIDPRICE[] = "MIDPRICE"; -static const char __pyx_k_MININDEX[] = "MININDEX"; -static const char __pyx_k_MINUS_DI[] = "MINUS_DI"; -static const char __pyx_k_MINUS_DM[] = "MINUS_DM"; -static const char __pyx_k_N_1_A_t1[] = "\200N\220!\360\016\000\t\014\2101\330\014\020\320\020!\240\021\240!\330\010\014\320\014\034\230A\330\010\017\210t\2201"; -static const char __pyx_k_RealBody[] = "RealBody"; -static const char __pyx_k_STOCHRSI[] = "STOCHRSI"; -static const char __pyx_k_TA_ADOSC[] = "TA_ADOSC"; -static const char __pyx_k_TA_AROON[] = "TA_AROON"; -static const char __pyx_k_TA_FLOOR[] = "TA_FLOOR"; -static const char __pyx_k_TA_LOG10[] = "TA_LOG10"; -static const char __pyx_k_TA_STOCH[] = "TA_STOCH"; -static const char __pyx_k_TA_TRIMA[] = "TA_TRIMA"; -static const char __pyx_k_TA_WILLR[] = "TA_WILLR"; -static const char __pyx_k_TYPPRICE[] = "TYPPRICE"; -static const char __pyx_k_WCLPRICE[] = "WCLPRICE"; -static const char __pyx_k_add_note[] = "add_note"; -static const char __pyx_k_defaults[] = "defaults"; -static const char __pyx_k_expected[] = " (expected "; -static const char __pyx_k_is_empty[] = "is_empty"; -static const char __pyx_k_lookback[] = "lookback"; -static const char __pyx_k_low_data[] = "low_data"; -static const char __pyx_k_outfastd[] = "outfastd"; -static const char __pyx_k_outfastk[] = "outfastk"; -static const char __pyx_k_outslowd[] = "outslowd"; -static const char __pyx_k_outslowk[] = "outslowk"; -static const char __pyx_k_property[] = "property"; -static const char __pyx_k_qualname[] = "__qualname__"; -static const char __pyx_k_ret_code[] = "ret_code"; -static const char __pyx_k_to_numpy[] = "to_numpy"; -static const char __pyx_k_A_t85_Q_2[] = "\200A\360\n\000\t\020\210t\2208\2305\240\001\240\037\260\005\260Q"; -static const char __pyx_k_BodyShort[] = "BodyShort"; -static const char __pyx_k_CDL2CROWS[] = "CDL2CROWS"; -static const char __pyx_k_CDLHAMMER[] = "CDLHAMMER"; -static const char __pyx_k_CDLHARAMI[] = "CDLHARAMI"; -static const char __pyx_k_CDLINNECK[] = "CDLINNECK"; -static const char __pyx_k_CDLONNECK[] = "CDLONNECK"; -static const char __pyx_k_CDLTAKURI[] = "CDLTAKURI"; -static const char __pyx_k_DataFrame[] = "DataFrame"; -static const char __pyx_k_HT_PHASOR[] = "HT_PHASOR"; -static const char __pyx_k_Histogram[] = "Histogram"; -static const char __pyx_k_LINEARREG[] = "LINEARREG"; -static const char __pyx_k_NameError[] = "NameError"; -static const char __pyx_k_RangeType[] = "RangeType"; -static const char __pyx_k_TA_AVGDEV[] = "TA_AVGDEV"; -static const char __pyx_k_TA_BBANDS[] = "TA_BBANDS"; -static const char __pyx_k_TA_CORREL[] = "TA_CORREL"; -static const char __pyx_k_TA_MINMAX[] = "TA_MINMAX"; -static const char __pyx_k_TA_SAREXT[] = "TA_SAREXT"; -static const char __pyx_k_TA_STDDEV[] = "TA_STDDEV"; -static const char __pyx_k_TA_STOCHF[] = "TA_STOCHF"; -static const char __pyx_k_TA_TRANGE[] = "TA_TRANGE"; -static const char __pyx_k_TA_ULTOSC[] = "TA_ULTOSC"; -static const char __pyx_k_TypeError[] = "TypeError"; -static const char __pyx_k_avgperiod[] = "avgperiod"; -static const char __pyx_k_bytes2str[] = "bytes2str"; -static const char __pyx_k_enumerate[] = "enumerate"; -static const char __pyx_k_fastlimit[] = "fastlimit"; -static const char __pyx_k_func_args[] = "func_args"; -static const char __pyx_k_func_info[] = "func_info"; -static const char __pyx_k_func_line[] = "func_line"; -static const char __pyx_k_functions[] = "functions"; -static const char __pyx_k_get_flags[] = "__get_flags"; -static const char __pyx_k_high_data[] = "high_data"; -static const char __pyx_k_maxperiod[] = "maxperiod"; -static const char __pyx_k_metaclass[] = "__metaclass__"; -static const char __pyx_k_minperiod[] = "minperiod"; -static const char __pyx_k_open_data[] = "open_data"; -static const char __pyx_k_opt_input[] = "opt_input"; -static const char __pyx_k_outbegidx[] = "outbegidx"; -static const char __pyx_k_outmaxidx[] = "outmaxidx"; -static const char __pyx_k_outminidx[] = "outminidx"; -static const char __pyx_k_rangetype[] = "rangetype"; -static const char __pyx_k_real_data[] = "real_data"; -static const char __pyx_k_slowlimit[] = "slowlimit"; -static const char __pyx_k_str2bytes[] = "str2bytes"; -static const char __pyx_k_stream_AD[] = "stream_AD"; -static const char __pyx_k_stream_DX[] = "stream_DX"; -static const char __pyx_k_stream_LN[] = "stream_LN"; -static const char __pyx_k_stream_MA[] = "stream_MA"; -static const char __pyx_k_stream_T3[] = "stream_T3"; -static const char __pyx_k_stream__s[] = "stream_%s"; -static const char __pyx_k_threading[] = "threading"; -static const char __pyx_k_timeStamp[] = "timeStamp"; -static const char __pyx_k_CDL3INSIDE[] = "CDL3INSIDE"; -static const char __pyx_k_CDLHIKKAKE[] = "CDLHIKKAKE"; -static const char __pyx_k_CDLKICKING[] = "CDLKICKING"; -static const char __pyx_k_CDLMATHOLD[] = "CDLMATHOLD"; -static const char __pyx_k_CDLTRISTAR[] = "CDLTRISTAR"; -static const char __pyx_k_HT_DCPHASE[] = "HT_DCPHASE"; -static const char __pyx_k_IndexError[] = "IndexError"; -static const char __pyx_k_Parameters[] = "Parameters:"; -static const char __pyx_k_Qa_q_A_Q_a[] = "\200\001\340\004\034\320\034-\250Q\250a\330\004\022\320\022'\240q\250\004\250A\330\004\025\220Q\320\026.\250a"; -static const char __pyx_k_ShadowLong[] = "ShadowLong"; -static const char __pyx_k_TA_CDLDOJI[] = "TA_CDLDOJI"; -static const char __pyx_k_TA_HT_SINE[] = "TA_HT_SINE"; -static const char __pyx_k_TA_MACDEXT[] = "TA_MACDEXT"; -static const char __pyx_k_TA_MACDFIX[] = "TA_MACDFIX"; -static const char __pyx_k_TA_PLUS_DI[] = "TA_PLUS_DI"; -static const char __pyx_k_TA_PLUS_DM[] = "TA_PLUS_DM"; -static const char __pyx_k_TA_ROCR100[] = "TA_ROCR100"; -static const char __pyx_k_close_data[] = "close_data"; -static const char __pyx_k_fastmatype[] = "fastmatype"; -static const char __pyx_k_fastperiod[] = "fastperiod"; -static const char __pyx_k_input_name[] = "input_name"; -static const char __pyx_k_num_inputs[] = "num_inputs"; -static const char __pyx_k_opt_inputs[] = "opt_inputs"; -static const char __pyx_k_outaroonup[] = "outaroonup"; -static const char __pyx_k_outinphase[] = "outinphase"; -static const char __pyx_k_outinteger[] = "outinteger"; -static const char __pyx_k_param_name[] = "param_name"; -static const char __pyx_k_parameters[] = "parameters"; -static const char __pyx_k_real0_data[] = "real0_data"; -static const char __pyx_k_real1_data[] = "real1_data"; -static const char __pyx_k_skip_first[] = "skip_first"; -static const char __pyx_k_slowmatype[] = "slowmatype"; -static const char __pyx_k_slowperiod[] = "slowperiod"; -static const char __pyx_k_startvalue[] = "startvalue"; -static const char __pyx_k_stream_ADD[] = "stream_ADD"; -static const char __pyx_k_stream_ADX[] = "stream_ADX"; -static const char __pyx_k_stream_APO[] = "stream_APO"; -static const char __pyx_k_stream_ATR[] = "stream_ATR"; -static const char __pyx_k_stream_BOP[] = "stream_BOP"; -static const char __pyx_k_stream_CCI[] = "stream_CCI"; -static const char __pyx_k_stream_CMO[] = "stream_CMO"; -static const char __pyx_k_stream_COS[] = "stream_COS"; -static const char __pyx_k_stream_DIV[] = "stream_DIV"; -static const char __pyx_k_stream_EMA[] = "stream_EMA"; -static const char __pyx_k_stream_EXP[] = "stream_EXP"; -static const char __pyx_k_stream_IMI[] = "stream_IMI"; -static const char __pyx_k_stream_MAX[] = "stream_MAX"; -static const char __pyx_k_stream_MFI[] = "stream_MFI"; -static const char __pyx_k_stream_MIN[] = "stream_MIN"; -static const char __pyx_k_stream_MOM[] = "stream_MOM"; -static const char __pyx_k_stream_OBV[] = "stream_OBV"; -static const char __pyx_k_stream_PPO[] = "stream_PPO"; -static const char __pyx_k_stream_ROC[] = "stream_ROC"; -static const char __pyx_k_stream_RSI[] = "stream_RSI"; -static const char __pyx_k_stream_SAR[] = "stream_SAR"; -static const char __pyx_k_stream_SIN[] = "stream_SIN"; -static const char __pyx_k_stream_SMA[] = "stream_SMA"; -static const char __pyx_k_stream_SUB[] = "stream_SUB"; -static const char __pyx_k_stream_SUM[] = "stream_SUM"; -static const char __pyx_k_stream_TAN[] = "stream_TAN"; -static const char __pyx_k_stream_TSF[] = "stream_TSF"; -static const char __pyx_k_stream_VAR[] = "stream_VAR"; -static const char __pyx_k_stream_WMA[] = "stream_WMA"; -static const char __pyx_k_ta_version[] = "__ta_version__"; -static const char __pyx_k_timeperiod[] = "timeperiod"; -static const char __pyx_k_ARRAY_TYPES[] = "__ARRAY_TYPES"; -static const char __pyx_k_CDL3OUTSIDE[] = "CDL3OUTSIDE"; -static const char __pyx_k_CDLBELTHOLD[] = "CDLBELTHOLD"; -static const char __pyx_k_CDLDOJISTAR[] = "CDLDOJISTAR"; -static const char __pyx_k_CDLHIGHWAVE[] = "CDLHIGHWAVE"; -static const char __pyx_k_CDLLONGLINE[] = "CDLLONGLINE"; -static const char __pyx_k_CDLMARUBOZU[] = "CDLMARUBOZU"; -static const char __pyx_k_CDLPIERCING[] = "CDLPIERCING"; -static const char __pyx_k_Dashed_Line[] = "Dashed Line"; -static const char __pyx_k_Dotted_Line[] = "Dotted Line"; -static const char __pyx_k_HT_DCPERIOD[] = "HT_DCPERIOD"; -static const char __pyx_k_ImportError[] = "ImportError"; -static const char __pyx_k_MINMAXINDEX[] = "MINMAXINDEX"; -static const char __pyx_k_OrderedDict[] = "OrderedDict"; -static const char __pyx_k_ShadowShort[] = "ShadowShort"; -static const char __pyx_k_TA_ACCBANDS[] = "TA_ACCBANDS"; -static const char __pyx_k_TA_AROONOSC[] = "TA_AROONOSC"; -static const char __pyx_k_TA_AVGPRICE[] = "TA_AVGPRICE"; -static const char __pyx_k_TA_MAXINDEX[] = "TA_MAXINDEX"; -static const char __pyx_k_TA_MEDPRICE[] = "TA_MEDPRICE"; -static const char __pyx_k_TA_MIDPOINT[] = "TA_MIDPOINT"; -static const char __pyx_k_TA_MIDPRICE[] = "TA_MIDPRICE"; -static const char __pyx_k_TA_MININDEX[] = "TA_MININDEX"; -static const char __pyx_k_TA_MINUS_DI[] = "TA_MINUS_DI"; -static const char __pyx_k_TA_MINUS_DM[] = "TA_MINUS_DM"; -static const char __pyx_k_TA_STOCHRSI[] = "TA_STOCHRSI"; -static const char __pyx_k_TA_Shutdown[] = "TA_Shutdown"; -static const char __pyx_k_TA_TYPPRICE[] = "TA_TYPPRICE"; -static const char __pyx_k_TA_WCLPRICE[] = "TA_WCLPRICE"; -static const char __pyx_k_any_ndarray[] = "(any ndarray)"; -static const char __pyx_k_collections[] = "collections"; -static const char __pyx_k_func_object[] = "func_object"; -static const char __pyx_k_input_names[] = "input_names"; -static const char __pyx_k_mro_entries[] = "__mro_entries__"; -static const char __pyx_k_num_outputs[] = "num_outputs"; -static const char __pyx_k_ordereddict[] = "ordereddict"; -static const char __pyx_k_outleadsine[] = "outleadsine"; -static const char __pyx_k_outmacdhist[] = "outmacdhist"; -static const char __pyx_k_output_name[] = "output_name"; -static const char __pyx_k_penetration[] = "penetration"; -static const char __pyx_k_settingtype[] = "settingtype"; -static const char __pyx_k_stream_ACOS[] = "stream_ACOS"; -static const char __pyx_k_stream_ADXR[] = "stream_ADXR"; -static const char __pyx_k_stream_ASIN[] = "stream_ASIN"; -static const char __pyx_k_stream_ATAN[] = "stream_ATAN"; -static const char __pyx_k_stream_BETA[] = "stream_BETA"; -static const char __pyx_k_stream_CEIL[] = "stream_CEIL"; -static const char __pyx_k_stream_COSH[] = "stream_COSH"; -static const char __pyx_k_stream_DEMA[] = "stream_DEMA"; -static const char __pyx_k_stream_KAMA[] = "stream_KAMA"; -static const char __pyx_k_stream_MACD[] = "stream_MACD"; -static const char __pyx_k_stream_MAMA[] = "stream_MAMA"; -static const char __pyx_k_stream_MAVP[] = "stream_MAVP"; -static const char __pyx_k_stream_MULT[] = "stream_MULT"; -static const char __pyx_k_stream_NATR[] = "stream_NATR"; -static const char __pyx_k_stream_ROCP[] = "stream_ROCP"; -static const char __pyx_k_stream_ROCR[] = "stream_ROCR"; -static const char __pyx_k_stream_SINH[] = "stream_SINH"; -static const char __pyx_k_stream_SQRT[] = "stream_SQRT"; -static const char __pyx_k_stream_TANH[] = "stream_TANH"; -static const char __pyx_k_stream_TEMA[] = "stream_TEMA"; -static const char __pyx_k_stream_TRIX[] = "stream_TRIX"; -static const char __pyx_k_ta_shutdown[] = "_ta_shutdown"; -static const char __pyx_k_timeperiod1[] = "timeperiod1"; -static const char __pyx_k_timeperiod2[] = "timeperiod2"; -static const char __pyx_k_timeperiod3[] = "timeperiod3"; -static const char __pyx_k_update_info[] = "update_info"; -static const char __pyx_k_value_range[] = "value_range"; -static const char __pyx_k_volume_data[] = "volume_data"; -static const char __pyx_k_BodyVeryLong[] = "BodyVeryLong"; -static const char __pyx_k_CDLBREAKAWAY[] = "CDLBREAKAWAY"; -static const char __pyx_k_CDLENGULFING[] = "CDLENGULFING"; -static const char __pyx_k_CDLSHORTLINE[] = "CDLSHORTLINE"; -static const char __pyx_k_CDLTASUKIGAP[] = "CDLTASUKIGAP"; -static const char __pyx_k_CDLTHRUSTING[] = "CDLTHRUSTING"; -static const char __pyx_k_Function_run[] = "Function.run"; -static const char __pyx_k_HT_TRENDLINE[] = "HT_TRENDLINE"; -static const char __pyx_k_HT_TRENDMODE[] = "HT_TRENDMODE"; -static const char __pyx_k_Pattern_Bool[] = "Pattern (Bool)"; -static const char __pyx_k_TA_CDL2CROWS[] = "TA_CDL2CROWS"; -static const char __pyx_k_TA_CDLHAMMER[] = "TA_CDLHAMMER"; -static const char __pyx_k_TA_CDLHARAMI[] = "TA_CDLHARAMI"; -static const char __pyx_k_TA_CDLINNECK[] = "TA_CDLINNECK"; -static const char __pyx_k_TA_CDLONNECK[] = "TA_CDLONNECK"; -static const char __pyx_k_TA_CDLTAKURI[] = "TA_CDLTAKURI"; -static const char __pyx_k_TA_HT_PHASOR[] = "TA_HT_PHASOR"; -static const char __pyx_k_TA_LINEARREG[] = "TA_LINEARREG"; -static const char __pyx_k_acceleration[] = "acceleration"; -static const char __pyx_k_column_stack[] = "column_stack"; -static const char __pyx_k_display_name[] = "display_name"; -static const char __pyx_k_fastd_matype[] = "fastd_matype"; -static const char __pyx_k_fastd_period[] = "fastd_period"; -static const char __pyx_k_fastk_period[] = "fastk_period"; -static const char __pyx_k_import_error[] = "import_error"; -static const char __pyx_k_initializing[] = "_initializing"; -static const char __pyx_k_input_arrays[] = "input_arrays"; -static const char __pyx_k_is_coroutine[] = "_is_coroutine"; -static const char __pyx_k_missing_keys[] = "missing_keys"; -static const char __pyx_k_openInterest[] = "openInterest"; -static const char __pyx_k_outaroondown[] = "outaroondown"; -static const char __pyx_k_outnbelement[] = "outnbelement"; -static const char __pyx_k_output_flags[] = "output_flags"; -static const char __pyx_k_output_names[] = "output_names"; -static const char __pyx_k_periods_data[] = "periods_data"; -static const char __pyx_k_price_series[] = "price_series"; -static const char __pyx_k_signalmatype[] = "signalmatype"; -static const char __pyx_k_signalperiod[] = "signalperiod"; -static const char __pyx_k_slowd_matype[] = "slowd_matype"; -static const char __pyx_k_slowd_period[] = "slowd_period"; -static const char __pyx_k_slowk_matype[] = "slowk_matype"; -static const char __pyx_k_slowk_period[] = "slowk_period"; -static const char __pyx_k_stream_ADOSC[] = "stream_ADOSC"; -static const char __pyx_k_stream_AROON[] = "stream_AROON"; -static const char __pyx_k_stream_FLOOR[] = "stream_FLOOR"; -static const char __pyx_k_stream_LOG10[] = "stream_LOG10"; -static const char __pyx_k_stream_STOCH[] = "stream_STOCH"; -static const char __pyx_k_stream_TRIMA[] = "stream_TRIMA"; -static const char __pyx_k_stream_WILLR[] = "stream_WILLR"; -static const char __pyx_k_CDLHANGINGMAN[] = "CDLHANGINGMAN"; -static const char __pyx_k_CDLHIKKAKEMOD[] = "CDLHIKKAKEMOD"; -static const char __pyx_k_Function_info[] = "Function.info"; -static const char __pyx_k_PANDAS_SERIES[] = "__PANDAS_SERIES"; -static const char __pyx_k_POLARS_SERIES[] = "__POLARS_SERIES"; -static const char __pyx_k_TA_CDL3INSIDE[] = "TA_CDL3INSIDE"; -static const char __pyx_k_TA_CDLHIKKAKE[] = "TA_CDLHIKKAKE"; -static const char __pyx_k_TA_CDLKICKING[] = "TA_CDLKICKING"; -static const char __pyx_k_TA_CDLMATHOLD[] = "TA_CDLMATHOLD"; -static const char __pyx_k_TA_CDLTRISTAR[] = "TA_CDLTRISTAR"; -static const char __pyx_k_TA_FUNC_FLAGS[] = "TA_FUNC_FLAGS"; -static const char __pyx_k_TA_HT_DCPHASE[] = "TA_HT_DCPHASE"; -static const char __pyx_k_TA_Initialize[] = "TA_Initialize"; -static const char __pyx_k_Unknown_Error[] = "Unknown Error"; -static const char __pyx_k_call_function[] = "__call_function"; -static const char __pyx_k_class_getitem[] = "__class_getitem__"; -static const char __pyx_k_default_value[] = "default_value"; -static const char __pyx_k_documentation[] = "documentation"; -static const char __pyx_k_function_name[] = "function_name"; -static const char __pyx_k_outmacdsignal[] = "outmacdsignal"; -static const char __pyx_k_outputs_valid[] = "outputs_valid"; -static const char __pyx_k_outquadrature[] = "outquadrature"; -static const char __pyx_k_stream_AVGDEV[] = "stream_AVGDEV"; -static const char __pyx_k_stream_BBANDS[] = "stream_BBANDS"; -static const char __pyx_k_stream_CORREL[] = "stream_CORREL"; -static const char __pyx_k_stream_MINMAX[] = "stream_MINMAX"; -static const char __pyx_k_stream_SAREXT[] = "stream_SAREXT"; -static const char __pyx_k_stream_STDDEV[] = "stream_STDDEV"; -static const char __pyx_k_stream_STOCHF[] = "stream_STOCHF"; -static const char __pyx_k_stream_TRANGE[] = "stream_TRANGE"; -static const char __pyx_k_stream_ULTOSC[] = "stream_ULTOSC"; -static const char __pyx_k_ta_initialize[] = "_ta_initialize"; -static const char __pyx_k_talib__ta_lib[] = "talib._ta_lib"; -static const char __pyx_k_CDL3BLACKCROWS[] = "CDL3BLACKCROWS"; -static const char __pyx_k_CDL3LINESTRIKE[] = "CDL3LINESTRIKE"; -static const char __pyx_k_CDLEVENINGSTAR[] = "CDLEVENINGSTAR"; -static const char __pyx_k_CDLHARAMICROSS[] = "CDLHARAMICROSS"; -static const char __pyx_k_CDLMATCHINGLOW[] = "CDLMATCHINGLOW"; -static const char __pyx_k_CDLMORNINGSTAR[] = "CDLMORNINGSTAR"; -static const char __pyx_k_CDLRICKSHAWMAN[] = "CDLRICKSHAWMAN"; -static const char __pyx_k_CDLSPINNINGTOP[] = "CDLSPINNINGTOP"; -static const char __pyx_k_Function___str[] = "Function.__str__"; -static const char __pyx_k_Function__name[] = "_Function__name"; -static const char __pyx_k_MA_Type___init[] = "MA_Type.__init__"; -static const char __pyx_k_ShadowVeryLong[] = "ShadowVeryLong"; -static const char __pyx_k_TA_CDL3OUTSIDE[] = "TA_CDL3OUTSIDE"; -static const char __pyx_k_TA_CDLBELTHOLD[] = "TA_CDLBELTHOLD"; -static const char __pyx_k_TA_CDLDOJISTAR[] = "TA_CDLDOJISTAR"; -static const char __pyx_k_TA_CDLHIGHWAVE[] = "TA_CDLHIGHWAVE"; -static const char __pyx_k_TA_CDLLONGLINE[] = "TA_CDLLONGLINE"; -static const char __pyx_k_TA_CDLMARUBOZU[] = "TA_CDLMARUBOZU"; -static const char __pyx_k_TA_CDLPIERCING[] = "TA_CDLPIERCING"; -static const char __pyx_k_TA_GetFuncInfo[] = "TA_GetFuncInfo"; -static const char __pyx_k_TA_GetLookback[] = "TA_GetLookback"; -static const char __pyx_k_TA_HT_DCPERIOD[] = "TA_HT_DCPERIOD"; -static const char __pyx_k_TA_INPUT_FLAGS[] = "TA_INPUT_FLAGS"; -static const char __pyx_k_TA_MINMAXINDEX[] = "TA_MINMAXINDEX"; -static const char __pyx_k_function_flags[] = "function_flags"; -static const char __pyx_k_get_parameters[] = "get_parameters"; -static const char __pyx_k_input_arrays_2[] = "[input_arrays]"; -static const char __pyx_k_num_opt_inputs[] = "num_opt_inputs"; -static const char __pyx_k_outmaxidx_data[] = "outmaxidx_data"; -static const char __pyx_k_outminidx_data[] = "outminidx_data"; -static const char __pyx_k_set_parameters[] = "set_parameters"; -static const char __pyx_k_stream_CDLDOJI[] = "stream_CDLDOJI"; -static const char __pyx_k_stream_HT_SINE[] = "stream_HT_SINE"; -static const char __pyx_k_stream_MACDEXT[] = "stream_MACDEXT"; -static const char __pyx_k_stream_MACDFIX[] = "stream_MACDFIX"; -static const char __pyx_k_stream_PLUS_DI[] = "stream_PLUS_DI"; -static const char __pyx_k_stream_PLUS_DM[] = "stream_PLUS_DM"; -static const char __pyx_k_stream_ROCR100[] = "stream_ROCR100"; -static const char __pyx_k_ta_getFuncInfo[] = "_ta_getFuncInfo"; -static const char __pyx_k_A_d_q_4z_q_aq_q[] = "\200A\360\n\000\t\017\210d\220(\230(\240%\240q\330\010\013\2104\210z\230\021\230%\230q\330\014\022\220$\220a\220q\330\010\017\210q"; -static const char __pyx_k_CDLADVANCEBLOCK[] = "CDLADVANCEBLOCK"; -static const char __pyx_k_CDLHOMINGPIGEON[] = "CDLHOMINGPIGEON"; -static const char __pyx_k_CDLLADDERBOTTOM[] = "CDLLADDERBOTTOM"; -static const char __pyx_k_CDLSHOOTINGSTAR[] = "CDLSHOOTINGSTAR"; -static const char __pyx_k_CDLUNIQUE3RIVER[] = "CDLUNIQUE3RIVER"; -static const char __pyx_k_Function___call[] = "Function.__call__"; -static const char __pyx_k_Function___init[] = "Function.__init__"; -static const char __pyx_k_Function___repr[] = "Function.__repr__"; -static const char __pyx_k_Function__local[] = "_Function__local"; -static const char __pyx_k_LINEARREG_ANGLE[] = "LINEARREG_ANGLE"; -static const char __pyx_k_LINEARREG_SLOPE[] = "LINEARREG_SLOPE"; -static const char __pyx_k_ShadowVeryShort[] = "ShadowVeryShort"; -static const char __pyx_k_TA_CDLBREAKAWAY[] = "TA_CDLBREAKAWAY"; -static const char __pyx_k_TA_CDLENGULFING[] = "TA_CDLENGULFING"; -static const char __pyx_k_TA_CDLSHORTLINE[] = "TA_CDLSHORTLINE"; -static const char __pyx_k_TA_CDLTASUKIGAP[] = "TA_CDLTASUKIGAP"; -static const char __pyx_k_TA_CDLTHRUSTING[] = "TA_CDLTHRUSTING"; -static const char __pyx_k_TA_HT_TRENDLINE[] = "TA_HT_TRENDLINE"; -static const char __pyx_k_TA_HT_TRENDMODE[] = "TA_HT_TRENDMODE"; -static const char __pyx_k_TA_OUTPUT_FLAGS[] = "TA_OUTPUT_FLAGS"; -static const char __pyx_k_get_input_names[] = "get_input_names"; -static const char __pyx_k_offsetonreverse[] = "offsetonreverse"; -static const char __pyx_k_outinteger_data[] = "outinteger_data"; -static const char __pyx_k_set_input_names[] = "set_input_names"; -static const char __pyx_k_stream_ACCBANDS[] = "stream_ACCBANDS"; -static const char __pyx_k_stream_AROONOSC[] = "stream_AROONOSC"; -static const char __pyx_k_stream_AVGPRICE[] = "stream_AVGPRICE"; -static const char __pyx_k_stream_MAXINDEX[] = "stream_MAXINDEX"; -static const char __pyx_k_stream_MEDPRICE[] = "stream_MEDPRICE"; -static const char __pyx_k_stream_MIDPOINT[] = "stream_MIDPOINT"; -static const char __pyx_k_stream_MIDPRICE[] = "stream_MIDPRICE"; -static const char __pyx_k_stream_MININDEX[] = "stream_MININDEX"; -static const char __pyx_k_stream_MINUS_DI[] = "stream_MINUS_DI"; -static const char __pyx_k_stream_MINUS_DM[] = "stream_MINUS_DM"; -static const char __pyx_k_stream_STOCHRSI[] = "stream_STOCHRSI"; -static const char __pyx_k_stream_TYPPRICE[] = "stream_TYPPRICE"; -static const char __pyx_k_stream_WCLPRICE[] = "stream_WCLPRICE"; -static const char __pyx_k_ta_getFuncTable[] = "_ta_getFuncTable"; -static const char __pyx_k_talib__func_pxi[] = "talib/_func.pxi"; -static const char __pyx_k_A_A_AQ_6_A_E_A_q[] = "\200A\360\010\000\t\021\220\004\220A\330\010\020\220\005\220[\240\001\240\033\250A\250Q\330\010\013\2106\220\023\220A\330\014\024\220E\230\033\240A\240[\260\001\260\021\330\010\017\210q"; -static const char __pyx_k_CDL3STARSINSOUTH[] = "CDL3STARSINSOUTH"; -static const char __pyx_k_CDLABANDONEDBABY[] = "CDLABANDONEDBABY"; -static const char __pyx_k_CDLCOUNTERATTACK[] = "CDLCOUNTERATTACK"; -static const char __pyx_k_CDLDRAGONFLYDOJI[] = "CDLDRAGONFLYDOJI"; -static const char __pyx_k_CDLSTICKSANDWICH[] = "CDLSTICKSANDWICH"; -static const char __pyx_k_Function___local[] = "Function.__local"; -static const char __pyx_k_Function_outputs[] = "Function.outputs"; -static const char __pyx_k_PANDAS_DATAFRAME[] = "__PANDAS_DATAFRAME"; -static const char __pyx_k_POLARS_DATAFRAME[] = "__POLARS_DATAFRAME"; -static const char __pyx_k_TA_CDLHANGINGMAN[] = "TA_CDLHANGINGMAN"; -static const char __pyx_k_TA_CDLHIKKAKEMOD[] = "TA_CDLHIKKAKEMOD"; -static const char __pyx_k_TA_FuncTableFree[] = "TA_FuncTableFree"; -static const char __pyx_k_TA_GetFuncHandle[] = "TA_GetFuncHandle"; -static const char __pyx_k_accelerationlong[] = "accelerationlong"; -static const char __pyx_k_get_input_arrays[] = "get_input_arrays"; -static const char __pyx_k_opt_input_values[] = "opt_input_values"; -static const char __pyx_k_outreallowerband[] = "outreallowerband"; -static const char __pyx_k_outrealupperband[] = "outrealupperband"; -static const char __pyx_k_set_input_arrays[] = "set_input_arrays"; -static const char __pyx_k_stream_CDL2CROWS[] = "stream_CDL2CROWS"; -static const char __pyx_k_stream_CDLHAMMER[] = "stream_CDLHAMMER"; -static const char __pyx_k_stream_CDLHARAMI[] = "stream_CDLHARAMI"; -static const char __pyx_k_stream_CDLINNECK[] = "stream_CDLINNECK"; -static const char __pyx_k_stream_CDLONNECK[] = "stream_CDLONNECK"; -static const char __pyx_k_stream_CDLTAKURI[] = "stream_CDLTAKURI"; -static const char __pyx_k_stream_HT_PHASOR[] = "stream_HT_PHASOR"; -static const char __pyx_k_stream_LINEARREG[] = "stream_LINEARREG"; -static const char __pyx_k_ta_check_success[] = "_ta_check_success"; -static const char __pyx_k_ta_func_unst_ids[] = "_ta_func_unst_ids"; -static const char __pyx_k_ta_getGroupTable[] = "_ta_getGroupTable"; -static const char __pyx_k_AllCandleSettings[] = "AllCandleSettings"; -static const char __pyx_k_CDL3WHITESOLDIERS[] = "CDL3WHITESOLDIERS"; -static const char __pyx_k_CDLDARKCLOUDCOVER[] = "CDLDARKCLOUDCOVER"; -static const char __pyx_k_CDLGRAVESTONEDOJI[] = "CDLGRAVESTONEDOJI"; -static const char __pyx_k_CDLINVERTEDHAMMER[] = "CDLINVERTEDHAMMER"; -static const char __pyx_k_CDLLONGLEGGEDDOJI[] = "CDLLONGLEGGEDDOJI"; -static const char __pyx_k_CDLSTALLEDPATTERN[] = "CDLSTALLEDPATTERN"; -static const char __pyx_k_CandleSettingType[] = "CandleSettingType"; -static const char __pyx_k_Function__namestr[] = "_Function__namestr"; -static const char __pyx_k_Function_lookback[] = "Function.lookback"; -static const char __pyx_k_MA_Type___getitem[] = "MA_Type.__getitem__"; -static const char __pyx_k_TA_CDL3BLACKCROWS[] = "TA_CDL3BLACKCROWS"; -static const char __pyx_k_TA_CDL3LINESTRIKE[] = "TA_CDL3LINESTRIKE"; -static const char __pyx_k_TA_CDLEVENINGSTAR[] = "TA_CDLEVENINGSTAR"; -static const char __pyx_k_TA_CDLHARAMICROSS[] = "TA_CDLHARAMICROSS"; -static const char __pyx_k_TA_CDLMATCHINGLOW[] = "TA_CDLMATCHINGLOW"; -static const char __pyx_k_TA_CDLMORNINGSTAR[] = "TA_CDLMORNINGSTAR"; -static const char __pyx_k_TA_CDLRICKSHAWMAN[] = "TA_CDLRICKSHAWMAN"; -static const char __pyx_k_TA_CDLSPINNINGTOP[] = "TA_CDLSPINNINGTOP"; -static const char __pyx_k_TA_FUNCTION_NAMES[] = "__TA_FUNCTION_NAMES__"; -static const char __pyx_k_TA_FuncTableAlloc[] = "TA_FuncTableAlloc"; -static const char __pyx_k_TA_GroupTableFree[] = "TA_GroupTableFree"; -static const char __pyx_k_accelerationshort[] = "accelerationshort"; -static const char __pyx_k_flags_lookup_dict[] = "flags_lookup_dict"; -static const char __pyx_k_outrealmiddleband[] = "outrealmiddleband"; -static const char __pyx_k_set_function_args[] = "set_function_args"; -static const char __pyx_k_stream_CDL3INSIDE[] = "stream_CDL3INSIDE"; -static const char __pyx_k_stream_CDLHIKKAKE[] = "stream_CDLHIKKAKE"; -static const char __pyx_k_stream_CDLKICKING[] = "stream_CDLKICKING"; -static const char __pyx_k_stream_CDLMATHOLD[] = "stream_CDLMATHOLD"; -static const char __pyx_k_stream_CDLTRISTAR[] = "stream_CDLTRISTAR"; -static const char __pyx_k_stream_HT_DCPHASE[] = "stream_HT_DCPHASE"; -static const char __pyx_k_talib__common_pxi[] = "talib/_common.pxi"; -static const char __pyx_k_talib__stream_pxi[] = "talib/_stream.pxi"; -static const char __pyx_k_A_A_k_M_a_q_T_7q_q[] = "\200A\360\010\000\t\021\220\004\220A\330\010\016\210k\230\021\330\010\014\210M\230\025\230a\330\014\017\210q\220\r\230T\320!7\260q\270\001\330\010\017\210q"; -static const char __pyx_k_CDLCLOSINGMARUBOZU[] = "CDLCLOSINGMARUBOZU"; -static const char __pyx_k_CDLEVENINGDOJISTAR[] = "CDLEVENINGDOJISTAR"; -static const char __pyx_k_CDLIDENTICAL3CROWS[] = "CDLIDENTICAL3CROWS"; -static const char __pyx_k_CDLKICKINGBYLENGTH[] = "CDLKICKINGBYLENGTH"; -static const char __pyx_k_CDLMORNINGDOJISTAR[] = "CDLMORNINGDOJISTAR"; -static const char __pyx_k_CDLSEPARATINGLINES[] = "CDLSEPARATINGLINES"; -static const char __pyx_k_CDLUPSIDEGAP2CROWS[] = "CDLUPSIDEGAP2CROWS"; -static const char __pyx_k_Function___unicode[] = "Function.__unicode__"; -static const char __pyx_k_INPUT_ARRAYS_TYPES[] = "__INPUT_ARRAYS_TYPES"; -static const char __pyx_k_Output_can_be_zero[] = "Output can be zero"; -static const char __pyx_k_Q_V1E_q_WAQ_Q_aq_1[] = "\200\001\360\n\000\005\026\220Q\320\026.\320.@\300\001\300\027\310\001\310\021\330\004\020\220\001\330\004\010\210\005\210V\2201\220E\230\021\330\010\021\220\027\230\001\230\026\230q\240\005\240W\250A\250Q\330\004\025\220Q\320\026-\320->\270a\270q\330\004\013\2101"; -static const char __pyx_k_TA_CDLADVANCEBLOCK[] = "TA_CDLADVANCEBLOCK"; -static const char __pyx_k_TA_CDLHOMINGPIGEON[] = "TA_CDLHOMINGPIGEON"; -static const char __pyx_k_TA_CDLLADDERBOTTOM[] = "TA_CDLLADDERBOTTOM"; -static const char __pyx_k_TA_CDLSHOOTINGSTAR[] = "TA_CDLSHOOTINGSTAR"; -static const char __pyx_k_TA_CDLUNIQUE3RIVER[] = "TA_CDLUNIQUE3RIVER"; -static const char __pyx_k_TA_GroupTableAlloc[] = "TA_GroupTableAlloc"; -static const char __pyx_k_TA_LINEARREG_ANGLE[] = "TA_LINEARREG_ANGLE"; -static const char __pyx_k_TA_LINEARREG_SLOPE[] = "TA_LINEARREG_SLOPE"; -static const char __pyx_k_TA_ParamHolderFree[] = "TA_ParamHolderFree"; -static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines"; -static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; -static const char __pyx_k_stream_CDL3OUTSIDE[] = "stream_CDL3OUTSIDE"; -static const char __pyx_k_stream_CDLBELTHOLD[] = "stream_CDLBELTHOLD"; -static const char __pyx_k_stream_CDLDOJISTAR[] = "stream_CDLDOJISTAR"; -static const char __pyx_k_stream_CDLHIGHWAVE[] = "stream_CDLHIGHWAVE"; -static const char __pyx_k_stream_CDLLONGLINE[] = "stream_CDLLONGLINE"; -static const char __pyx_k_stream_CDLMARUBOZU[] = "stream_CDLMARUBOZU"; -static const char __pyx_k_stream_CDLPIERCING[] = "stream_CDLPIERCING"; -static const char __pyx_k_stream_HT_DCPERIOD[] = "stream_HT_DCPERIOD"; -static const char __pyx_k_stream_MINMAXINDEX[] = "stream_MINMAXINDEX"; -static const char __pyx_k_A_A_gQ_5_q_5_V1_5_U[] = "\200A\360\010\000\t\021\220\004\220A\330\010\013\320\013\036\230g\240Q\330\014\020\220\n\230!\2305\240\017\250q\330\014\023\2205\230\r\240V\2501\340\014\023\2205\230\r\240U\250!"; -static const char __pyx_k_CDLCONCEALBABYSWALL[] = "CDLCONCEALBABYSWALL"; -static const char __pyx_k_CDLGAPSIDESIDEWHITE[] = "CDLGAPSIDESIDEWHITE"; -static const char __pyx_k_CDLRISEFALL3METHODS[] = "CDLRISEFALL3METHODS"; -static const char __pyx_k_CDLXSIDEGAP3METHODS[] = "CDLXSIDEGAP3METHODS"; -static const char __pyx_k_Function__localdata[] = "_Function__localdata"; -static const char __pyx_k_LINEARREG_INTERCEPT[] = "LINEARREG_INTERCEPT"; -static const char __pyx_k_ModuleNotFoundError[] = "ModuleNotFoundError"; -static const char __pyx_k_TA_CDL3STARSINSOUTH[] = "TA_CDL3STARSINSOUTH"; -static const char __pyx_k_TA_CDLABANDONEDBABY[] = "TA_CDLABANDONEDBABY"; -static const char __pyx_k_TA_CDLCOUNTERATTACK[] = "TA_CDLCOUNTERATTACK"; -static const char __pyx_k_TA_CDLDRAGONFLYDOJI[] = "TA_CDLDRAGONFLYDOJI"; -static const char __pyx_k_TA_CDLSTICKSANDWICH[] = "TA_CDLSTICKSANDWICH"; -static const char __pyx_k_TA_ParamHolderAlloc[] = "TA_ParamHolderAlloc"; -static const char __pyx_k_TA_SetCompatibility[] = "TA_SetCompatibility"; -static const char __pyx_k_accelerationmaxlong[] = "accelerationmaxlong"; -static const char __pyx_k_get_opt_input_value[] = "__get_opt_input_value"; -static const char __pyx_k_stream_CDLBREAKAWAY[] = "stream_CDLBREAKAWAY"; -static const char __pyx_k_stream_CDLENGULFING[] = "stream_CDLENGULFING"; -static const char __pyx_k_stream_CDLSHORTLINE[] = "stream_CDLSHORTLINE"; -static const char __pyx_k_stream_CDLTASUKIGAP[] = "stream_CDLTASUKIGAP"; -static const char __pyx_k_stream_CDLTHRUSTING[] = "stream_CDLTHRUSTING"; -static const char __pyx_k_stream_HT_TRENDLINE[] = "stream_HT_TRENDLINE"; -static const char __pyx_k_stream_HT_TRENDMODE[] = "stream_HT_TRENDMODE"; -static const char __pyx_k_talib__abstract_pxi[] = "talib/_abstract.pxi"; -static const char __pyx_k_A_A_L_6_Qk_A_a_QnA_a[] = "\200A\360\010\000\t\021\220\004\220A\330\010\014\210L\320\030(\250\013\2606\270\021\330\014\021\220\034\230Q\230k\250\021\320*<\270A\330\014\021\220\025\220a\220~\240Q\240n\260A\330\010\r\320\r\036\230a"; -static const char __pyx_k_A_A_k_N_q_q_e_q_1A_q[] = "\200A\360\n\000\t\021\220\004\220A\330\010\016\210k\230\021\330\010\014\210N\230%\230q\330\014\017\210q\220\016\230e\240<\250q\260\013\2701\270A\330\010\017\210q"; -static const char __pyx_k_TA_CDL3WHITESOLDIERS[] = "TA_CDL3WHITESOLDIERS"; -static const char __pyx_k_TA_CDLDARKCLOUDCOVER[] = "TA_CDLDARKCLOUDCOVER"; -static const char __pyx_k_TA_CDLGRAVESTONEDOJI[] = "TA_CDLGRAVESTONEDOJI"; -static const char __pyx_k_TA_CDLINVERTEDHAMMER[] = "TA_CDLINVERTEDHAMMER"; -static const char __pyx_k_TA_CDLLONGLEGGEDDOJI[] = "TA_CDLLONGLEGGEDDOJI"; -static const char __pyx_k_TA_CDLSTALLEDPATTERN[] = "TA_CDLSTALLEDPATTERN"; -static const char __pyx_k_TA_SetCandleSettings[] = "TA_SetCandleSettings"; -static const char __pyx_k_TA_SetUnstablePeriod[] = "TA_SetUnstablePeriod"; -static const char __pyx_k_accelerationinitlong[] = "accelerationinitlong"; -static const char __pyx_k_accelerationmaxshort[] = "accelerationmaxshort"; -static const char __pyx_k_stream_CDLHANGINGMAN[] = "stream_CDLHANGINGMAN"; -static const char __pyx_k_stream_CDLHIKKAKEMOD[] = "stream_CDLHIKKAKEMOD"; -static const char __pyx_k_ta_get_compatibility[] = "_ta_get_compatibility"; -static const char __pyx_k_ta_set_compatibility[] = "_ta_set_compatibility"; -static const char __pyx_k_Function_output_flags[] = "Function.output_flags"; -static const char __pyx_k_Function_output_names[] = "Function.output_names"; -static const char __pyx_k_Output_is_over_volume[] = "Output is over volume"; -static const char __pyx_k_Simple_Moving_Average[] = "Simple Moving Average"; -static const char __pyx_k_TA_CDLCLOSINGMARUBOZU[] = "TA_CDLCLOSINGMARUBOZU"; -static const char __pyx_k_TA_CDLEVENINGDOJISTAR[] = "TA_CDLEVENINGDOJISTAR"; -static const char __pyx_k_TA_CDLIDENTICAL3CROWS[] = "TA_CDLIDENTICAL3CROWS"; -static const char __pyx_k_TA_CDLKICKINGBYLENGTH[] = "TA_CDLKICKINGBYLENGTH"; -static const char __pyx_k_TA_CDLMORNINGDOJISTAR[] = "TA_CDLMORNINGDOJISTAR"; -static const char __pyx_k_TA_CDLSEPARATINGLINES[] = "TA_CDLSEPARATINGLINES"; -static const char __pyx_k_TA_CDLUPSIDEGAP2CROWS[] = "TA_CDLUPSIDEGAP2CROWS"; -static const char __pyx_k_accelerationinitshort[] = "accelerationinitshort"; -static const char __pyx_k_check_opt_input_value[] = "__check_opt_input_value"; -static const char __pyx_k_get_defaults_and_docs[] = "_get_defaults_and_docs"; -static const char __pyx_k_stream_CDL3BLACKCROWS[] = "stream_CDL3BLACKCROWS"; -static const char __pyx_k_stream_CDL3LINESTRIKE[] = "stream_CDL3LINESTRIKE"; -static const char __pyx_k_stream_CDLEVENINGSTAR[] = "stream_CDLEVENINGSTAR"; -static const char __pyx_k_stream_CDLHARAMICROSS[] = "stream_CDLHARAMICROSS"; -static const char __pyx_k_stream_CDLMATCHINGLOW[] = "stream_CDLMATCHINGLOW"; -static const char __pyx_k_stream_CDLMORNINGSTAR[] = "stream_CDLMORNINGSTAR"; -static const char __pyx_k_stream_CDLRICKSHAWMAN[] = "stream_CDLRICKSHAWMAN"; -static const char __pyx_k_stream_CDLSPINNINGTOP[] = "stream_CDLSPINNINGTOP"; -static const char __pyx_k_A_A_6_6_6_7_7_81_7_7_5[] = "\200A\330\010\014\210A\330\014\023\2206\230\021\330\014\023\2206\230\021\330\014\023\2206\230\021\330\014\023\2207\230!\330\014\023\2207\230!\330\014\023\2208\2301\330\014\023\2207\230!\330\014\023\2207\230!\330\014\023\2205\230\001"; -static const char __pyx_k_Output_can_be_negative[] = "Output can be negative"; -static const char __pyx_k_Output_can_be_positive[] = "Output can be positive"; -static const char __pyx_k_Q_B_1A_Q_V1E_gQfAU_Q_1[] = "\200\001\360\n\000\005\026\220Q\320\026/\320/B\300!\3001\300A\330\004\r\210Q\330\004\010\210\005\210V\2201\220E\230\021\330\010\016\210g\220Q\220f\230A\230U\240'\250\021\250!\330\004\025\220Q\320\026.\320.@\300\001\300\021\330\004\013\2101"; -static const char __pyx_k_TA_CDLCONCEALBABYSWALL[] = "TA_CDLCONCEALBABYSWALL"; -static const char __pyx_k_TA_CDLGAPSIDESIDEWHITE[] = "TA_CDLGAPSIDESIDEWHITE"; -static const char __pyx_k_TA_CDLRISEFALL3METHODS[] = "TA_CDLRISEFALL3METHODS"; -static const char __pyx_k_TA_CDLXSIDEGAP3METHODS[] = "TA_CDLXSIDEGAP3METHODS"; -static const char __pyx_k_TA_LINEARREG_INTERCEPT[] = "TA_LINEARREG_INTERCEPT"; -static const char __pyx_k_display_name_s_group_s[] = "%(display_name)s (%(group)s)\n"; -static const char __pyx_k_stream_CDLADVANCEBLOCK[] = "stream_CDLADVANCEBLOCK"; -static const char __pyx_k_stream_CDLHOMINGPIGEON[] = "stream_CDLHOMINGPIGEON"; -static const char __pyx_k_stream_CDLLADDERBOTTOM[] = "stream_CDLLADDERBOTTOM"; -static const char __pyx_k_stream_CDLSHOOTINGSTAR[] = "stream_CDLSHOOTINGSTAR"; -static const char __pyx_k_stream_CDLUNIQUE3RIVER[] = "stream_CDLUNIQUE3RIVER"; -static const char __pyx_k_stream_LINEARREG_ANGLE[] = "stream_LINEARREG_ANGLE"; -static const char __pyx_k_stream_LINEARREG_SLOPE[] = "stream_LINEARREG_SLOPE"; -static const char __pyx_k_ta_get_unstable_period[] = "_ta_get_unstable_period"; -static const char __pyx_k_ta_set_candle_settings[] = "_ta_set_candle_settings"; -static const char __pyx_k_ta_set_unstable_period[] = "_ta_set_unstable_period"; -static const char __pyx_k_Function__call_function[] = "_Function__call_function"; -static const char __pyx_k_Function_function_flags[] = "Function.function_flags"; -static const char __pyx_k_Function_get_parameters[] = "Function.get_parameters"; -static const char __pyx_k_Function_set_parameters[] = "Function.set_parameters"; -static const char __pyx_k_Output_is_a_candlestick[] = "Output is a candlestick"; -static const char __pyx_k_TA_SetOptInputParamReal[] = "TA_SetOptInputParamReal"; -static const char __pyx_k_Weighted_Moving_Average[] = "Weighted Moving Average"; -static const char __pyx_k_stream_CDL3STARSINSOUTH[] = "stream_CDL3STARSINSOUTH"; -static const char __pyx_k_stream_CDLABANDONEDBABY[] = "stream_CDLABANDONEDBABY"; -static const char __pyx_k_stream_CDLCOUNTERATTACK[] = "stream_CDLCOUNTERATTACK"; -static const char __pyx_k_stream_CDLDRAGONFLYDOJI[] = "stream_CDLDRAGONFLYDOJI"; -static const char __pyx_k_stream_CDLSTICKSANDWICH[] = "stream_CDLSTICKSANDWICH"; -static const char __pyx_k_A_Jm6_M_Q_Jiq_A_O9F_b_O1[] = "\200A\340\010\014\210J\220m\2406\250\021\330\010\014\210M\230\024\230Q\330\010\014\210J\220i\230q\240\004\240A\360\006\000\t\r\210O\2309\240F\250!\360\006\000\t\r\320\014\036\230b\240\010\250\001\330\010\014\210O\2301"; -static const char __pyx_k_Bad_Object_TA_BAD_OBJECT[] = "Bad Object (TA_BAD_OBJECT)"; -static const char __pyx_k_Function___call_function[] = "Function.__call_function"; -static const char __pyx_k_Function_get_input_names[] = "Function.get_input_names"; -static const char __pyx_k_Function_set_input_names[] = "Function.set_input_names"; -static const char __pyx_k_TA_GetInputParameterInfo[] = "TA_GetInputParameterInfo"; -static const char __pyx_k_input_price_series_names[] = "input_price_series_names"; -static const char __pyx_k_no_existing_input_arrays[] = "no_existing_input_arrays"; -static const char __pyx_k_price_series_name_values[] = "price_series_name_values"; -static const char __pyx_k_stream_CDL3WHITESOLDIERS[] = "stream_CDL3WHITESOLDIERS"; -static const char __pyx_k_stream_CDLDARKCLOUDCOVER[] = "stream_CDLDARKCLOUDCOVER"; -static const char __pyx_k_stream_CDLGRAVESTONEDOJI[] = "stream_CDLGRAVESTONEDOJI"; -static const char __pyx_k_stream_CDLINVERTEDHAMMER[] = "stream_CDLINVERTEDHAMMER"; -static const char __pyx_k_stream_CDLLONGLEGGEDDOJI[] = "stream_CDLLONGLEGGEDDOJI"; -static const char __pyx_k_stream_CDLSTALLEDPATTERN[] = "stream_CDLSTALLEDPATTERN"; -static const char __pyx_k_ta_getInputParameterInfo[] = "_ta_getInputParameterInfo"; -static const char __pyx_k_Function_get_input_arrays[] = "Function.get_input_arrays"; -static const char __pyx_k_Function_set_input_arrays[] = "Function.set_input_arrays"; -static const char __pyx_k_TA_GetOutputParameterInfo[] = "TA_GetOutputParameterInfo"; -static const char __pyx_k_Triangular_Moving_Average[] = "Triangular Moving Average"; -static const char __pyx_k_stream_CDLCLOSINGMARUBOZU[] = "stream_CDLCLOSINGMARUBOZU"; -static const char __pyx_k_stream_CDLEVENINGDOJISTAR[] = "stream_CDLEVENINGDOJISTAR"; -static const char __pyx_k_stream_CDLIDENTICAL3CROWS[] = "stream_CDLIDENTICAL3CROWS"; -static const char __pyx_k_stream_CDLKICKINGBYLENGTH[] = "stream_CDLKICKINGBYLENGTH"; -static const char __pyx_k_stream_CDLMORNINGDOJISTAR[] = "stream_CDLMORNINGDOJISTAR"; -static const char __pyx_k_stream_CDLSEPARATINGLINES[] = "stream_CDLSEPARATINGLINES"; -static const char __pyx_k_stream_CDLUPSIDEGAP2CROWS[] = "stream_CDLUPSIDEGAP2CROWS"; -static const char __pyx_k_ta_getOutputParameterInfo[] = "_ta_getOutputParameterInfo"; -static const char __pyx_k_A_A_1_N_q_5_A_z_HA_G1A_q_q[] = "\200A\330\010\020\220\004\220A\330\010#\2401\330\010\014\210N\230%\230q\330\014\033\2305\240\014\250A\250[\270\001\270\021\330\014\017\210z\230\021\230.\250\001\330\020\024\220H\230A\330\024,\250G\2601\260A\340\020(\250\007\250q\260\001\330\010\017\210q"; -static const char __pyx_k_Bad_Parameter_TA_BAD_PARAM[] = "Bad Parameter (TA_BAD_PARAM)"; -static const char __pyx_k_Exponential_Moving_Average[] = "Exponential Moving Average"; -static const char __pyx_k_Function_set_function_args[] = "Function.set_function_args"; -static const char __pyx_k_Output_scale_same_as_input[] = "Output scale same as input"; -static const char __pyx_k_TA_SetOptInputParamInteger[] = "TA_SetOptInputParamInteger"; -static const char __pyx_k_input_price_series_names_2[] = "__input_price_series_names"; -static const char __pyx_k_stream_CDLCONCEALBABYSWALL[] = "stream_CDLCONCEALBABYSWALL"; -static const char __pyx_k_stream_CDLGAPSIDESIDEWHITE[] = "stream_CDLGAPSIDESIDEWHITE"; -static const char __pyx_k_stream_CDLRISEFALL3METHODS[] = "stream_CDLRISEFALL3METHODS"; -static const char __pyx_k_stream_CDLXSIDEGAP3METHODS[] = "stream_CDLXSIDEGAP3METHODS"; -static const char __pyx_k_stream_LINEARREG_INTERCEPT[] = "stream_LINEARREG_INTERCEPT"; -static const char __pyx_k_INPUT_PRICE_SERIES_DEFAULTS[] = "__INPUT_PRICE_SERIES_DEFAULTS"; -static const char __pyx_k_Invalid_parameter_value_for[] = "Invalid parameter value for "; -static const char __pyx_k_TA_GetOptInputParameterInfo[] = "TA_GetOptInputParameterInfo"; -static const char __pyx_k_ta_getOptInputParameterInfo[] = "_ta_getOptInputParameterInfo"; -static const char __pyx_k_MESA_Adaptive_Moving_Average[] = "MESA Adaptive Moving Average"; -static const char __pyx_k_Q_A_1_G9JfA_t_1G1_q_1_a_U_4q[] = "\320\004\035\230Q\360\010\000\t\021\220\004\220A\330\010\025\220[\240\003\2401\330\010\022\220'\230\021\230!\330\010\014\210G\2209\230J\240f\250A\330\014\017\210t\320\023+\2501\250G\2601\330\020\025\220[\240\001\240\026\240q\250\013\2601\330\010\r\320\r\036\230a\330\010\r\210U\220!\320\023#\2404\240q"; -static const char __pyx_k_Unknown_Error_TA_UNKNOWN_ERR[] = "Unknown Error (TA_UNKNOWN_ERR)"; -static const char __pyx_k_aq_Q_T_q_a_fHBd_a_kkllm_Qj_1[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310a\310|\320[\\\320\\k\320kl\320lm\330\004\025\220Q\220j\240\001\330\004\013\2101"; -static const char __pyx_k_Allocation_Error_TA_ALLOC_ERR[] = "Allocation Error (TA_ALLOC_ERR)"; -static const char __pyx_k_Function__get_opt_input_value[] = "_Function__get_opt_input_value"; -static const char __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w[] = "\200\001\340_`\360.\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0330\260\002\260!\330\004\027\320\027(\250\001\250\030\260\021\330\004\030\320\030)\250\021\250(\260!\330\004\027\320\027(\250\001\250\030\260\021\330\004\021\220\034\230R\230t\2409\250K\260t\2706\300\021\300)\310;\320VY\320Y_\320_`\320`i\320it\320ty\320y\360\000\000@\002A\002\360\000\000A\002J\002\360\000\000J\002W\002\360\000\000W\002X\002\360\000\000X\002d\002\360\000\000d\002e\002\360\000\000e\002t\002\360\000\000t\002\002\360\000\000\002O\003\360\000\000O\003U\003\360\000\000U\003V\003\360\000\000V\003a\003\360\000\000a\003l\003\360\000\000l\003}\003\360\000\000}\003C\004\360\000\000C\004D\004\360\000\000D\004O\004\360\000\000O\004Z\004\360\000\000Z\004j\004\360\000\000j\004p\004\360\000\000p\004q\004\360\000\000q\004r\004\330\004\025\220Q\220o\240Q\330\004\013\320\013\036\320\0362\260!"; -static const char __pyx_k_01_aq_T_q_8_T_U_7_A_we_7r_q_Bd[] = "\200\001\34001\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0337\260r\270\021\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\320\021$\240B\240d\250)\260;\270d\300&\310\001\310\031\320R_\320_`\320`l\320lm\320m|\360\000\000}\001H\002\360\000\000H\002O\002\360\000\000O\002U\002\360\000\000U\002V\002\360\000\000V\002W\002\330\004\025\220Q\320\026,\250A\330\004\013\2101"; -static const char __pyx_k_1_aq_T_q_8_T_U_7_A_we_M_q_r_Yk[] = "\200\001\340#;\2701\360(\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\230?\250\"\250M\270\021\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\026\220r\230\024\230Y\240k\260\024\260V\2701\270I\300]\320R[\320[\\\320\\h\320hi\320ix\360\000\000y\001D\002\360\000\000D\002K\002\360\000\000K\002Q\002\360\000\000Q\002R\002\360\000\000R\002S\002\330\004\025\220Q\220i\230q\330\004\013\2101"; -static const char __pyx_k_314DAQ_Q_a_4q_a_Qd_c_a_Qd_s_4q[] = "\200\001\360\014\000\005\022\220\037\240\001\320!3\2601\3204D\300A\300Q\330\004\025\220Q\320\026(\250\001\340\004\005\330\010\020\220\t\230\021\230$\230a\330\010\021\220\031\230!\2304\230q\330\010\030\230\t\240\021\240$\240a\330\010\032\230+\240Q\240d\250(\260!\330\010\026\220c\230\021\230$\230a\330\010\032\230#\230Q\230d\240!\330\010\027\220s\230!\2304\230q"; -static const char __pyx_k_BC_Kq_Kq_7_8_U_E_U_7_A_we_Ba_q[] = "\200\001\340BC\360(\000\005\r\210K\220q\230\001\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2307\240!\330\004\r\210]\230!\2308\240:\250U\260(\270*\300E\310\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033,\250B\250a\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\030\230\022\2304\230y\250\013\2605\270\006\270a\270y\310\013\320SX\320X^\320^_\320_h\320hu\320uv\360\000\000w\001C\002\360\000\000C\002D\002\360\000\000D\002S\002\360\000\000S\002^\002\360\000\000^\002e\002\360\000\000e\002k\002\360\000\000k\002l\002\360\000\000l\002m\002\330\004\025\220Q\220k\240\021\330\004\013\2101"; -static const char __pyx_k_BC_aq_Qa_6_8_T_3a_U_7_A_we_r_q[] = "\200\001\340BC\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300a\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033/\250r\260\021\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\033\230B\230d\240)\250;\260d\270&\300\001\300\031\310+\320UX\320X^\320^_\320_h\320hu\320uv\360\000\000w\001C\002\360\000\000C\002D\002\360\000\000D\002S\002\360\000\000S\002^\002\360\000\000^\002e\002\360\000\000e\002k\002\360\000\000k\002l\002\360\000\000l\002m\002\330\004\025\220Q\220n\240A\330\004\013\2101"; -static const char __pyx_k_C1_aq_Q_T_q_a_fHBd_m_ccddppq_r[] = "\200\001\340+C\3001\360(\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310m\320[c\320cd\320dp\320pq\360\000\000r\001A\002\360\000\000A\002B\002\360\000\000B\002C\002\330\004\025\220Q\220j\240\001\330\004\013\2101"; -static const char __pyx_k_CD_aq_Qa_6_8_T_3a_U_7_A_we_0_q[] = "\200\001\340CD\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300a\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0330\260\002\260!\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\034\230R\230t\2409\250K\260t\2706\300\021\300)\310;\320VY\320Y_\320_`\320`i\320iv\320vw\360\000\000x\001D\002\360\000\000D\002E\002\360\000\000E\002T\002\360\000\000T\002_\002\360\000\000_\002f\002\360\000\000f\002l\002\360\000\000l\002m\002\360\000\000m\002n\002\330\004\025\220Q\220o\240Q\330\004\013\2101"; -static const char __pyx_k_D_E_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA[] = "\200\001\360\004\000D\002E\002\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\220\036\230r\240\026\240x\250r\260\024\260V\2708\3002\300T\310\034\320Ua\320al\320ly\360\000\000z\001H\002\360\000\000H\002I\002\360\000\000I\002U\002\360\000\000U\002V\002\360\000\000V\002e\002\360\000\000e\002f\002\360\000\000f\002g\002\330\004\025\220Q\320\026'\240q\330\004\013\2101"; -static const char __pyx_k_Function___get_opt_input_value[] = "Function.__get_opt_input_value"; -static const char __pyx_k_H_I_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA[] = "\200\001\360\004\000H\002I\002\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021#\2402\240V\2508\2602\260T\270\026\270x\300r\310\024\310\\\320Ye\320ep\320p}\360\000\000~\001L\002\360\000\000L\002M\002\360\000\000M\002Y\002\360\000\000Y\002Z\002\360\000\000Z\002i\002\360\000\000i\002j\002\360\000\000j\002k\002\330\004\025\220Q\320\026+\2501\330\004\013\2101"; -static const char __pyx_k_Hb_c_B_B_f_f_F_F_i_i_N_N_o_o_p[] = "\200\001\340Hb\360\000\000c\001B\002\360\000\000B\002f\002\360\000\000f\002F\003\360\000\000F\003i\003\360\000\000i\003N\004\360\000\000N\004o\004\360\000\000o\004p\004\3606\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\r\210]\230!\2306\240\021\330\004\016\210a\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300\\\320Q\\\320\\i\320i{\360\000\000|\001S\002\360\000\000S\002f\002\360\000\000f\002|\002\360\000\000|\002T\003\360\000\000T\003h\003\360\000\000h\003\003\360\000\000\003@\004\360\000\000@\004L\004\360\000\000L\004M\004\360\000\000M\004\\\004\360\000\000\\\004]\004\360\000\000]\004^\004\330\004\025\220Q\220m\2401\330\004\013\2101"; -static const char __pyx_k_J_K_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA[] = "\200\001\360\004\000J\002K\002\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021%\240R\240v\250X\260R\260t\2706\300\030\310\022\3104\310|\320[g\320gr\320r\360\000\000@\002N\002\360\000\000N\002O\002\360\000\000O\002[\002\360\000\000[\002\\\002\360\000\000\\\002k\002\360\000\000k\002l\002\360\000\000l\002m\002\330\004\025\220Q\320\026-\250Q\330\004\013\2101"; -static const char __pyx_k_K_L_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA[] = "\200\001\360\004\000K\002L\002\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021&\240b\250\006\250h\260b\270\004\270F\300(\310\"\310D\320P\\\320\\h\320hs\360\000\000t\001A\002\360\000\000A\002O\002\360\000\000O\002P\002\360\000\000P\002\\\002\360\000\000\\\002]\002\360\000\000]\002l\002\360\000\000l\002m\002\360\000\000m\002n\002\330\004\025\220Q\320\026.\250a\330\004\013\2101"; -static const char __pyx_k_Kq_q_Kq_q_7_a_6_4vXRt_P_jjkkzz[] = "\200\001\360*\000\005\r\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2307\240!\330\004\016\210a\330\004\021\220\030\230\022\2306\240\030\250\022\2504\250v\260X\270R\270t\300=\320P]\320]^\320^j\320jk\320kz\320z{\320{|\330\004\025\220Q\220k\240\021\330\004\013\2101"; -static const char __pyx_k_Kq_q_Kq_q_7_a_fHBd_iijjyyzz_Qj[] = "\200\001\360*\000\005\r\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2307\240!\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300-\310}\320\\]\320]i\320ij\320jy\320yz\320z{\330\004\025\220Q\220j\240\001\330\004\013\2101"; -static const char __pyx_k_L_M_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA[] = "\200\001\360\004\000L\002M\002\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021'\240r\250\026\250x\260r\270\024\270V\3008\3102\310T\320Q]\320]i\320it\360\000\000u\001B\002\360\000\000B\002P\002\360\000\000P\002Q\002\360\000\000Q\002]\002\360\000\000]\002^\002\360\000\000^\002m\002\360\000\000m\002n\002\360\000\000n\002o\002\330\004\025\220Q\320\026/\250q\330\004\013\2101"; -static const char __pyx_k_Not_Supported_TA_NOT_SUPPORTED[] = "Not Supported (TA_NOT_SUPPORTED)"; -static const char __pyx_k_Values_represent_a_lower_limit[] = "Values represent a lower limit"; -static const char __pyx_k_YZ_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A[] = "\200\001\340YZ\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\230?\250\"\250A\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\026\220r\230\024\230Y\240k\260\024\260V\2701\270I\300[\320PS\320SY\320YZ\320Zc\320cn\320ns\320sy\320yz\360\000\000{\001D\002\360\000\000D\002Q\002\360\000\000Q\002R\002\360\000\000R\002^\002\360\000\000^\002_\002\360\000\000_\002n\002\360\000\000n\002y\002\360\000\000y\002@\003\360\000\000@\003F\003\360\000\000F\003G\003\360\000\000G\003H\003\330\004\025\220Q\220i\230q\330\004\013\2101"; -static const char __pyx_k_ab_aq_Q_Qa_y_1_Kq_q_6_a_a_fHBd[] = "\200\001\340ab\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310k\320Yf\320fs\320st\360\000\000u\001A\002\360\000\000A\002B\002\360\000\000B\002Q\002\360\000\000Q\002R\002\360\000\000R\002S\002\330\004\025\220Q\220j\240\001\330\004\013\2101"; -static const char __pyx_k_aq_Q_Qa_y_1_Kq_q_6_6_gQ_a_fHBd[] = "\200\001\340~\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210[\230\001\230\021\330\004\022\220)\2306\240\021\330\004\r\210]\230!\2306\240\025\240g\250Q\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310k\320Yf\320ft\360\000\000u\001B\002\360\000\000B\002C\002\360\000\000C\002O\002\360\000\000O\002P\002\360\000\000P\002_\002\360\000\000_\002`\002\360\000\000`\002a\002\330\004\025\220Q\220j\240\001\330\004\013\2101"; -static const char __pyx_k_aq_Q_Qa_y_1_Kq_q_6_6_gQ_a_r_xr[] = "\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210[\230\001\230\021\330\004\022\220)\2306\240\021\330\004\r\210]\230!\2306\240\025\240g\250Q\330\004\016\210a\330\004\021\220\026\220r\230\026\230x\240r\250\024\250V\2608\2702\270T\300\034\310[\320Xe\320es\320st\360\000\000u\001A\002\360\000\000A\002B\002\360\000\000B\002Q\002\360\000\000Q\002R\002\360\000\000R\002S\002\330\004\025\220Q\220i\230q\330\004\013\2101"; -static const char __pyx_k_aq_Q_T_q_Q_Q_2V82T_xr_Q___kkll[] = "\200\001\340./\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\r\210Q\330\004\r\210Q\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300\\\320Q^\320^_\320_k\320kl\320l{\320{|\360\000\000}\001F\002\360\000\000F\002G\002\360\000\000G\002H\002\330\004\025\220Q\220m\2401\330\004\013\2109\220A"; -static const char __pyx_k_aq_Q_T_q_a_6_4vXRt_iijjyyzz_Qk[] = "\200\001\340,-\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\030\230\022\2306\240\030\250\022\2504\250v\260X\270R\270t\300<\310}\320\\]\320]i\320ij\320jy\320yz\320z{\330\004\025\220Q\220k\240\021\330\004\013\2101"; -static const char __pyx_k_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\030\230\022\2306\240\030\250\022\2504\250v\260X\270R\270t\300<\310q\320P\\\320\\]\320]l\320lm\320mn\330\004\025\220Q\220k\240\021\330\004\013\2101"; -static const char __pyx_k_aq_Q_T_q_a_BfHBd_lRSS___ooppzz[] = "\200\001\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\022\220!\330\004\021\220\033\230B\230f\240H\250B\250d\260&\270\010\300\002\300$\300l\320RS\320S_\320_`\320`o\320op\320pz\320z{\320{|\330\004\025\220Q\220n\240A\330\004\013\210:\220Q"; -static const char __pyx_k_aq_Q_T_q_a_F_D_hb_LP_jjkkzz_Ql[] = "\200\001\340-.\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\031\230\"\230F\240(\250\"\250D\260\006\260h\270b\300\004\300L\320P]\320]^\320^j\320jk\320kz\320z{\320{|\330\004\025\220Q\220l\240!\330\004\013\2101"; -static const char __pyx_k_aq_Q_T_q_a_fHBdR_kkllxxy_z_I_I[] = "\200\001\340;<\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\320\021(\250\002\250&\260\010\270\002\270$\270f\300H\310B\310d\320R^\320^k\320kl\320lx\320xy\360\000\000z\001I\002\360\000\000I\002J\002\360\000\000J\002K\002\330\004\025\220Q\320\0260\260\001\330\004\013\2101"; -static const char __pyx_k_aq_Q_T_q_a_fHBd_VWWccddssttu_Q[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\037\240\002\240&\250\010\260\002\260$\260f\270H\300B\300d\310,\320VW\320Wc\320cd\320ds\320st\320tu\330\004\025\220Q\320\026(\250\001\330\004\013\2101"; -static const char __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj[] = "\200\001\340+,\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310m\320[\\\320\\h\320hi\320ix\320xy\320yz\330\004\025\220Q\220j\240\001\330\004\013\2101"; -static const char __pyx_k_aq_Q_T_q_a_r_xr_V82T_QlZ_jjkkl[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\026\220r\230\026\230x\240r\250\024\250V\2608\2702\270T\300\034\310Q\310l\320Z[\320[j\320jk\320kl\330\004\025\220Q\220i\230q\330\004\013\2101"; -static const char __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_F_D[] = "\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021\"\240\"\240F\250(\260\"\260D\270\006\270h\300b\310\004\310L\320Xd\320do\320o|\320|}\360\000\000~\001J\002\360\000\000J\002K\002\360\000\000K\002Z\002\360\000\000Z\002[\002\360\000\000[\002\\\002\330\004\025\220Q\320\026*\250!\330\004\013\2101"; -static const char __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we[] = "\200\001\340[\\\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033,\250B\250a\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\030\230\022\2304\230y\250\013\2604\260v\270Q\270i\300{\320RU\320U[\320[\\\320\\e\320ep\320pu\320u{\320{|\360\000\000}\001F\002\360\000\000F\002S\002\360\000\000S\002T\002\360\000\000T\002`\002\360\000\000`\002a\002\360\000\000a\002p\002\360\000\000p\002{\002\360\000\000{\002B\003\360\000\000B\003H\003\360\000\000H\003I\003\360\000\000I\003J\003\330\004\025\220Q\220k\240\021\330\004\013\2101"; -static const char __pyx_k_aq_Qa_Kq_6_gQ_8_T_3hjX_eeoouuv[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210[\230\001\230\021\330\004\r\210]\230!\2306\240\025\240g\250Q\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]e\320eo\320ou\320uv\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\230?\250!\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\026\220r\230\024\230Y\240k\260\024\260V\2701\270I\300[\320PS\320SY\320YZ\320Zc\320cn\320ns\320sy\320yz\360\000\000{\001D\002\360\000\000D\002O\002\360\000\000O\002U\002\360\000\000U\002[\002\360\000\000[\002\\\002\360\000\000\\\002e\002\360\000\000e\002f\002\360\000\000f\002r\002\360\000\000r\002s\002\360\000\000s\002B\003\360\000\000B\003M\003\360\000\000M\003T\003\360\000\000T\003Z\003\360\000\000Z\003[\003\360\000\000[\003\\\003\330\004\025\220Q\220i\230q\330\004\013\2101"; -static const char __pyx_k_aq_T_q_8_T_U_7_A_we_0_q_Rt9Kt6[] = "\200\001\340)*\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0330\260\002\260!\330\004\021\220\036\230q\240\010\250\001\330\004\021\220\034\230R\230t\2409\250K\260t\2706\300\021\300)\310=\320XY\320Ye\320ef\320fu\320u}\360\000\000~\001H\002\360\000\000H\002N\002\360\000\000N\002O\002\360\000\000O\002P\002\330\004\025\220Q\220o\240Q\330\004\026\220f\230J\240a\330\004\010\210\007\320\017\037\230q\330\010\027\220q\230\006\230a\330\004\013\2101"; -static const char __pyx_k_aq_T_q_8_T_U_7_A_we_1_81_Qha_b[] = "\200\001\360*\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0331\260\021\330\004\021\320\021\"\240!\2408\2501\330\004\024\320\024%\240Q\240h\250a\330\004\021\220\035\230b\240\004\240I\250[\270\004\270F\300!\3009\310A\310\\\320YZ\320Zi\320it\320t~\360\000\000\001E\002\360\000\000E\002F\002\360\000\000F\002Q\002\360\000\000Q\002\\\002\360\000\000\\\002i\002\360\000\000i\002o\002\360\000\000o\002p\002\360\000\000p\002q\002\330\004\025\220Q\320\026&\240a\330\004\013\210=\230\001"; -static const char __pyx_k_aq_T_q_8_T_U_7_A_we_1_q_i_fAYa[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2501\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260$\260f\270A\270Y\300a\300|\320ST\320Tc\320cn\320nu\320u{\320{|\320|}\330\004\025\220Q\220j\240\001\330\004\013\2101"; -static const char __pyx_k_aq_T_q_8_T_U_7_A_we_Q_q_D_D_ay[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033-\250Q\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\031\230\"\230D\240\t\250\033\260D\270\006\270a\270y\310\001\310\034\320UV\320Ve\320ep\320pw\320w}\320}~\320~\330\004\025\220Q\220l\240!\330\004\013\2101"; -static const char __pyx_k_aq_T_q_8_T_U_7_A_we_b_q_2T_T_q[] = "\200\001\340'(\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033.\250b\260\001\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\032\2302\230T\240\031\250+\260T\270\026\270q\300\t\310\035\320VW\320Wc\320cd\320ds\320s~\360\000\000\001F\002\360\000\000F\002L\002\360\000\000L\002M\002\360\000\000M\002N\002\330\004\025\220Q\220m\2401\330\004\013\2101"; -static const char __pyx_k_aq_T_q_8_T_U_7_A_we_q_q_1HA_Bd[] = "\200\001\360*\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033/\250q\330\004\016\320\016\037\230q\240\010\250\001\330\004\022\320\022#\2401\240H\250A\330\004\021\220\033\230B\230d\240)\250;\260d\270&\300\001\300\031\310!\310<\320WX\320Xg\320gr\320ry\320y\360\000\000@\002A\002\360\000\000A\002L\002\360\000\000L\002W\002\360\000\000W\002b\002\360\000\000b\002h\002\360\000\000h\002i\002\360\000\000i\002j\002\330\004\025\220Q\220n\240A\330\004\013\210:\220Q"; -static const char __pyx_k_d_W_W_X_aq_Q_Qa_y_1_Kq_q_6_a_a[] = "\200\001\340d}\360\000\000~\001W\002\360\000\000W\002X\002\360.\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\016\210a\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300\\\320Q\\\320\\i\320iw\360\000\000x\001F\002\360\000\000F\002T\002\360\000\000T\002U\002\360\000\000U\002a\002\360\000\000a\002b\002\360\000\000b\002q\002\360\000\000q\002r\002\360\000\000r\002s\002\330\004\025\220Q\220m\2401\330\004\013\2101"; -static const char __pyx_k_d_Y_Y_Z_2_aq_Q_Qa_y_1_Kq_q_6_a[] = "\200\001\340d~\360\000\000\001Y\002\360\000\000Y\002Z\002\3602\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\017\210q\330\004\017\210q\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300\\\320Q\\\320\\i\320ix\360\000\000y\001H\002\360\000\000H\002W\002\360\000\000W\002X\002\360\000\000X\002d\002\360\000\000d\002e\002\360\000\000e\002t\002\360\000\000t\002u\002\360\000\000u\002@\003\360\000\000@\003A\003\360\000\000A\003B\003\330\004\025\220Q\220m\2401\330\004\013\210;\220a"; -static const char __pyx_k_input_array_type_is_not_double[] = "input array type is not double"; -static const char __pyx_k_q_9A_1_q_1_1_1A_q_a_1A_4z_A_G1[] = "\200\001\360\014\000\005\020\210q\330\004\020\220\001\220\031\230!\2309\240A\330\004\020\220\001\220\021\330\004\013\2101\330\004\010\210\007\210q\320\0201\260\022\2601\340\004\022\220)\2301\230A\330\004\010\210\007\210q\220\001\330\004\010\210\016\220a\330\010\020\220\013\2301\230A\330\010\013\2104\210z\230\021\230'\240\021\330\014\024\220A\330\010\014\210G\2201\320\024$\240L\260\001\340\004\r\210Y\220a\220q\330\004\007\200q\330\010\014\210G\2201\220A\330\004\010\210\t\220\021\330\010\014\210G\2201\320\024$\240G\2506\260\021\260!\330\010\021\220\027\230\001\230\035\240g\250V\2601\260A\330\010\020\220\001\220\031\230&\240\001\240\021\330\010\013\2106\220\023\220A\330\014\020\220\002\220%\220s\230%\230q\240\001\240\024\240R\240t\2507\260\"\260G\2701\270F\300!\3001\340\004\016\210i\220q\230\001\330\004\010\210\007\210q\220\001\330\004\010\210\n\220!\330\010\013\2107\220#\220Q\330\014\025\220Q\330\010\014\210G\2201\220I\230R\230q\340\004\r\210W\220A\220T\230\025\230a\230q\330\004\r\210W\220A\220Q\330\004\010\210\007\210q\220\003\2202\220U\230!\2301\330\004\024\220D\230\005\230Q\230a\330\004\013\210:\220Q"; -static const char __pyx_k_q_aq_T_q_8_T_U_7_A_we_b_Q_q_2T[] = "\200\001\340'?\270q\360(\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033.\250b\260\r\270Q\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\032\2302\230T\240\031\250+\260T\270\026\270q\300\t\310\035\320V^\320^_\320_k\320kl\320l{\360\000\000|\001G\002\360\000\000G\002N\002\360\000\000N\002T\002\360\000\000T\002U\002\360\000\000U\002V\002\330\004\025\220Q\220m\2401\330\004\013\2101"; -static const char __pyx_k_v_w_Q_Q_f_f_A_2_aq_Qa_Kq_6_a_8[] = "\200\001\340\\v\360\000\000w\001Q\002\360\000\000Q\002f\002\360\000\000f\002@\003\360\000\000@\003A\003\3602\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033-\250R\250\270o\310_\320\\k\320kl\330\004\017\320\017 \240\001\240\030\250\021\330\004\017\320\017 \240\001\240\030\250\021\330\004\021\220\031\230\"\230D\240\t\250\033\260D\270\006\270a\270y\310\013\320SV\320V\\\320\\]\320]f\320fq\320qv\320v|\320|}\360\000\000~\001G\002\360\000\000G\002V\002\360\000\000V\002e\002\360\000\000e\002t\002\360\000\000t\002C\003\360\000\000C\003R\003\360\000\000R\003S\003\360\000\000S\003_\003\360\000\000_\003`\003\360\000\000`\003o\003\360\000\000o\003z\003\360\000\000z\003B\004\360\000\000B\004H\004\360\000\000H\004I\004\360\000\000I\004T\004\360\000\000T\004_\004\360\000\000_\004g\004\360\000\000g\004m\004\360\000\000m\004n\004\360\000\000n\004o\004\330\004\025\220Q\220l\240!\330\004\013\210;\220a"; -static const char __pyx_k_z_R_R_S_aq_Qa_Kq_6_gQ_8_T_3hjX[] = "\200\001\360\004\000z\001R\002\360\000\000R\002S\002\360(\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210[\230\001\230\021\330\004\r\210]\230!\2306\240\025\240g\250Q\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]e\320eo\320ou\320uv\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033-\250R\250}\270A\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\031\230\"\230D\240\t\250\033\260D\270\006\270a\270y\310\013\320SV\320V\\\320\\]\320]f\320fq\320qv\320v|\320|}\360\000\000~\001G\002\360\000\000G\002R\002\360\000\000R\002X\002\360\000\000X\002^\002\360\000\000^\002_\002\360\000\000_\002h\002\360\000\000h\002u\002\360\000\000u\002B\003\360\000\000B\003C\003\360\000\000C\003O\003\360\000\000O\003P\003\360\000\000P\003_\003\360\000\000_\003j\003\360\000\000j\003q\003\360\000\000q\003w\003\360\000\000w\003x\003\360\000\000x\003y\003\330\004\025\220Q\220l\240!\330\004\013\2101"; -static const char __pyx_k_01_aq_Q_T_q_RvXRt6_4_S_aammnn_Q[] = "\200\001\34001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\021\220\021\330\004\021\220\034\230R\230v\240X\250R\250t\2606\270\030\300\022\3004\300|\320S`\320`a\320am\320mn\320n}\320}~\320~\330\004\025\220Q\220o\240Q\330\004\013\2101"; -static const char __pyx_k_01_aq_Q_T_q_a_RvXRt6_4_S_aammnn[] = "\200\001\34001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\034\230R\230v\240X\250R\250t\2606\270\030\300\022\3004\300|\320S`\320`a\320am\320mn\320n}\320}~\320~\330\004\025\220Q\220o\240Q\330\004\013\2101"; -static const char __pyx_k_0HHbb_0_aq_Q_T_q_q_q_RvXRt6_4_S[] = "\200\001\3400H\320Hb\320b|\320|}\3600\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\017\210q\330\004\017\210q\330\004\021\220\034\230R\230v\240X\250R\250t\2606\270\030\300\022\3004\300|\320S`\320`o\320o~\360\000\000\001N\002\360\000\000N\002O\002\360\000\000O\002[\002\360\000\000[\002\\\002\360\000\000\\\002k\002\360\000\000k\002l\002\360\000\000l\002w\002\360\000\000w\002x\002\360\000\000x\002y\002\330\004\025\220Q\220o\240Q\330\004\013\210;\220a"; -static const char __pyx_k_0_aq_Q_T_q_a_A_BfHBd_lRaabbnnoo[] = "\200\001\340/0\360.\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\024\220A\330\004\022\220!\330\004\021\220\033\230B\230f\240H\250B\250d\260&\270\010\300\002\300$\300l\320Ra\320ab\320bn\320no\320o~\320~\360\000\000@\002J\002\360\000\000J\002K\002\360\000\000K\002[\002\360\000\000[\002\\\002\360\000\000\\\002]\002\330\004\025\220Q\220n\240A\330\004\013\210:\320\025%\240Q"; -static const char __pyx_k_0_aq_Q_T_q_a_BfHBd_lR___llmm_Qn[] = "\200\001\340/0\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\033\230B\230f\240H\250B\250d\260&\270\010\300\002\300$\300l\320R_\320_`\320`l\320lm\320m|\320|}\320}~\330\004\025\220Q\220n\240A\330\004\013\2101"; -static const char __pyx_k_12_aq_Q_T_q_a_b_hb_F_D_Taabbnno[] = "\200\001\34012\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\035\230b\240\006\240h\250b\260\004\260F\270(\300\"\300D\310\014\320Ta\320ab\320bn\320no\320o~\320~\360\000\000@\002A\002\330\004\025\220Q\320\026&\240a\330\004\013\2101"; -static const char __pyx_k_1_a_OuTUUV_Q_31_9AT_4q_1HF_wc_d[] = "\200\001\360\014\000\005\022\320\021+\2501\320,>\270a\320?O\310u\320TU\320UV\330\004\025\220Q\320\0263\2601\340\004\013\2109\220A\220T\230\021\330\004\013\2104\210q\220\003\2201\220H\230F\240!\340\004\007\200w\210c\220\025\220d\230%\230x\240x\250y\270\001\330\010\017\210t\2201\220C\220q\230\001\340\004\005\330\010\020\220\001\330\010\021\220\033\230A\230T\240\030\250\021"; -static const char __pyx_k_34_aq_Q_T_q_fHBd_Vccddppq_r_A_A[] = "\200\001\34034\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\020\220\001\330\004\020\220\001\330\004\021\220\037\240\002\240&\250\010\260\002\260$\260f\270H\300B\300d\310,\320Vc\320cd\320dp\320pq\360\000\000r\001A\002\360\000\000A\002B\002\360\000\000B\002N\002\360\000\000N\002O\002\360\000\000O\002P\002\330\004\025\220Q\320\026(\250\001\330\004\013\210<\220q"; -static const char __pyx_k_45_aq_T_q_8_T_U_7_A_we_2Q_q_i_f[] = "\200\001\34045\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033;\2702\270Q\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\320\021(\250\002\250$\250i\260{\300$\300f\310A\310Y\320Vc\320cd\320dp\320pq\360\000\000r\001A\002\360\000\000A\002L\002\360\000\000L\002S\002\360\000\000S\002Y\002\360\000\000Y\002Z\002\360\000\000Z\002[\002\330\004\025\220Q\320\0260\260\001\330\004\013\2101"; -static const char __pyx_k_5_t_Qm1_d_1_c_d_3a_Q_c_d_3a_Q_u[] = "\200\001\360\014\000\005\023\320\022#\2405\250\001\330\004\007\200t\210:\220Q\220m\2401\330\010\026\220d\230!\2301\330\004\016\210c\220\021\220$\220d\230!\2303\230a\230~\250Q\330\004\016\210c\220\021\220$\220d\230!\2303\230a\230~\250Q\360\006\000\005\010\200u\210B\210b\220\003\2205\230\002\230!\2302\230Q\330\010\017\210q\360\n\000\005\013\210!\330\004\010\210\005\210V\2201\220I\230W\240A\240Q\330\010\013\2101\210B\210b\220\002\220!\330\014\017\210w\220a\320\027(\250\001\250\021\250\"\250A\330\004\013\2101"; -static const char __pyx_k_78_aq_Q_T_q_a_BfHBd_lZgghhttu_v[] = "\200\001\34078\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\320\021$\240B\240f\250H\260B\260d\270&\300\010\310\002\310$\310l\320Zg\320gh\320ht\320tu\360\000\000v\001E\002\360\000\000E\002F\002\360\000\000F\002G\002\330\004\025\220Q\320\026,\250A\330\004\013\2101"; -static const char __pyx_k_AA_uuv0_aq_T_q_8_T_U_7_A_we_0_o[] = "\200\001\340)A\320A[\320[u\320uv\3600\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0330\260\002\260-\270\310o\320]^\330\004\017\320\017 \240\001\240\030\250\021\330\004\017\320\017 \240\001\240\030\250\021\330\004\021\220\034\230R\230t\2409\250K\260t\2706\300\021\300)\310=\320Xg\320gv\360\000\000w\001F\002\360\000\000F\002G\002\360\000\000G\002S\002\360\000\000S\002T\002\360\000\000T\002c\002\360\000\000c\002n\002\360\000\000n\002v\002\360\000\000v\002|\002\360\000\000|\002}\002\360\000\000}\002H\003\360\000\000H\003S\003\360\000\000S\003[\003\360\000\000[\003a\003\360\000\000a\003b\003\360\000\000b\003c\003\330\004\025\220Q\220o\240Q\330\004\013\210;\220a"; -static const char __pyx_k_A_A_2_k_Qa_e_e1_2S_AQ_U_t1A_q_4[] = "\200A\360\016\000\t\021\220\004\220A\340\010\033\2302\230\\\250\025\250k\270\021\270+\300Q\300a\330\034 \240\016\250e\260;\270e\3001\330\010#\2402\240S\250\005\250\\\270\021\270\"\270A\270Q\330$(\250\005\250U\260!\360\006\000\t\020\210t\2201\220A\330\010\027\220q\330\010#\2404\320'B\300!\330\010\013\2105\220\004\220D\230\n\240!\2404\240q\250\004\250A\330\014\020\220\003\2207\230)\2401\240A\330\020\023\2204\220z\240\021\240%\240q\330\024\025\340\020\021\330\024 \240\001\320!9\270\021\270&\300\001\330\027\030\330\024\032\320\032G\300q\330\030\033\2301\230A\330\030\034\230E\240\021\240!\330\024\032\230)\2401\240A\340\010\013\320\013\036\230g\240Q\330\020\024\220J\230a\230u\240O\2601\330\014'\240u\250M\270\021\330\r \240\007\240q\330\020\024\220J\230a\230u\240O\2601\330\014'\240u\250M\270\031\300!\340\014'\240t\2504\250q\260\005\260Q\340\010\013\2103\210a\210~\230S\240\003\2401\240A\330\014\020\320\020!\240\021\240!\330\014\023\2204\220q\230\003\2301\230A\330\r\020\220\001\220\036\230t\320#<\270A\330\020\024\220C\220q\230\006\230c\240\024\240Z\250q\260\004\260A\260T\270\021\330\014\022\320\022A\300\021\330\020\023\2201\220A\330\020\024\220E\230\021\230!\330\014\022\220)\2301\230A\340\010\014\320\014\036\230b\240\010\250\001\330\010\014\320\014\034\230A\360\006\000\t\r\210L\230\t\240\021\330\014\021\220\033\230A\230[\250\001\250\033\260A\330\010\r\210U\220!\320\023#\2404\240q\360\006\000\t\r\210L\230\t\240\021\330\014\021\220\034\230Q\230k\250\021\320*<\270A\330\014\021\220\025\220a\220~\240Q\240n\260A\340\010\017\210t\2201"; -static const char __pyx_k_A_A_4wawa_1_Kq_Q_V1E_d_1_0_Ya_T[] = "\200A\340\010\020\220\004\220A\330\010\013\2104\210w\220a\220w\230a\330\014\021\220\030\230\021\330\014\021\320\021!\240\021\360\006\000\r\022\220\037\240\013\2501\330\014\021\220\036\230{\250!\330\014\021\220\033\230K\240q\330\014\021\320\021\"\240!\360\006\000\r\022\220\030\230\037\250\001\250\024\250Q\360\006\000\r\021\220\005\220V\2301\230E\240\025\240d\250!\2501\330\020\027\320\0270\260\001\260\024\260Y\270a\330\020\035\230T\240\021\240!\330\020\023\2204\220q\320\030(\250\003\2501\330\024\030\230\001\320\031+\320+H\310\001\310\021\330\020\025\220\\\240\021\240.\260\001\330\014\021\220\025\220a\320\027(\250\004\250A\360\006\000\r\021\220\005\220V\2301\230E\240\025\240d\250!\2501\330\020\027\320\0273\2601\260D\270\t\300\021\330\020\035\230T\240\021\240!\330\020\025\220[\240\001\240\036\250q\330\014\021\220\025\220a\320\027'\240t\2501\360\006\000\r\022\220\025\220a\320\027)\250\033\260A\330\014\020\220\005\220V\2301\230E\240\025\240d\250!\2501\330\020\027\320\0271\260\021\260$\260i\270q\330\020\036\230d\240!\2401\330\020\025\220U\230!\230?\250!\250?\270$\270a\270q\330\020\025\220X\230Q\230o\250Q\330\014\021\220\025\220a\320\027)\250\024\250Q\330\010\017\210q"; -static const char __pyx_k_A_A_a_G1_t3e1_aq_4_q_Q_AT_V1A_S[] = "\200A\360\010\000\t\021\220\004\220A\330\010\026\220a\340\010\014\210G\2201\330\014\017\210t\2203\220e\2301\330\020\030\230\006\230a\230q\330\020\023\2204\320\027/\250q\260\005\260Q\330\024\031\230\033\240A\240T\250\021\250+\260V\2701\270A\330\024\"\240!\330\021\025\220S\230\005\230Q\330\020\025\220\\\240\021\240$\240a\320'9\270\026\270q\300\001\330\020\025\220U\230!\230>\250\021\250'\260\026\260q\270\001\340\010\013\2101\330\014\031\230\021\330\014\017\210t\320\023$\240A\240T\250\021\250!\330\020\035\230Q\330\014\017\210s\220!\2206\230\022\2301\330\020\024\220C\220~\240Y\250a\250u\260A\330\024\031\230\021\330\024\027\220r\230\022\2303\230a\230q\330\030 \240\004\240A\240Q\330\030\033\2304\320\0377\260q\270\014\300A\330\034!\240\033\250A\250[\270\001\270\033\300A\330\034*\250!\340\010\013\2105\220\003\2201\330\014\017\210q\330\020\025\220U\230!\320\033+\2504\250q\330\014\021\320\021\"\240!"; -static const char __pyx_k_A_B_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d[] = "\200\001\360\004\000A\002B\002\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0336\260b\270\001\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021#\2402\240T\250\031\260+\270T\300\026\300q\310\t\320Q\\\320\\`\320`f\320fg\320gp\320p{\320{~\360\000\000\001E\002\360\000\000E\002F\002\360\000\000F\002O\002\360\000\000O\002Z\002\360\000\000Z\002_\002\360\000\000_\002e\002\360\000\000e\002f\002\360\000\000f\002o\002\360\000\000o\002}\002\360\000\000}\002~\002\360\000\000~\002J\003\360\000\000J\003K\003\360\000\000K\003Z\003\360\000\000Z\003b\003\360\000\000b\003l\003\360\000\000l\003r\003\360\000\000r\003s\003\360\000\000s\003t\003\330\004\025\220Q\320\026+\2501\330\004\013\2101"; -static const char __pyx_k_A_Y_Y_Z_aq_Q_Qa_y_1_Kq_q_6_6_gQ[] = "\200\001\360\004\000A\002Y\002\360\000\000Y\002Z\002\360.\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210[\230\001\230\021\330\004\022\220)\2306\240\021\330\004\r\210]\230!\2306\240\025\240g\250Q\330\004\016\210a\330\004\021\220\031\230\"\230F\240(\250\"\250D\260\006\260h\270b\300\004\300L\320P[\320[h\320hv\360\000\000w\001D\002\360\000\000D\002Q\002\360\000\000Q\002R\002\360\000\000R\002^\002\360\000\000^\002_\002\360\000\000_\002n\002\360\000\000n\002o\002\360\000\000o\002p\002\330\004\025\220Q\220l\240!\330\004\013\2101"; -static const char __pyx_k_A_aq_Kq_6_8_T_5_U_7_A_we_2Q_q_i[] = "\200\001\340@A\360&\000\005\014\210;\220a\220q\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3005\310\001\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2502\250Q\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260$\260f\270A\270Y\300k\320QV\320V\\\320\\]\320]f\320fs\320st\360\000\000u\001A\002\360\000\000A\002B\002\360\000\000B\002Q\002\360\000\000Q\002\\\002\360\000\000\\\002c\002\360\000\000c\002i\002\360\000\000i\002j\002\360\000\000j\002k\002\330\004\025\220Q\220j\240\001\330\004\013\2101"; -static const char __pyx_k_A_aq_Qa_6_8_T_3a_U_7_A_we_Rq_AX[] = "\200\001\340@A\360*\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300a\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033-\250R\250q\330\004\023\320\023$\240A\240X\250Q\330\004\021\320\021\"\240!\2408\2501\330\004\021\220\031\230\"\230D\240\t\250\033\260D\270\006\270a\270y\310\013\320SV\320V\\\320\\]\320]f\320fs\320st\360\000\000u\001A\002\360\000\000A\002B\002\360\000\000B\002Q\002\360\000\000Q\002\\\002\360\000\000\\\002h\002\360\000\000h\002n\002\360\000\000n\002o\002\360\000\000o\002z\002\360\000\000z\002E\003\360\000\000E\003O\003\360\000\000O\003U\003\360\000\000U\003V\003\360\000\000V\003W\003\330\004\025\220Q\220l\240!\330\004\013\210?\230!"; -static const char __pyx_k_A_aq_T_q_8_T_U_7_A_we_2_q_i_fAY[] = "\200\001\340$<\270A\360(\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2502\250]\270!\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260$\260f\270A\270Y\300m\320S[\320[\\\320\\h\320hi\320ix\360\000\000y\001D\002\360\000\000D\002K\002\360\000\000K\002Q\002\360\000\000Q\002R\002\360\000\000R\002S\002\330\004\025\220Q\220j\240\001\330\004\013\2101"; -static const char __pyx_k_A_z_____b_b_G_G_h_h_i_4_aq_Qa_6[] = "\200\001\340A[\320[z\360\000\000{\001_\002\360\000\000_\002\002\360\000\000\002b\003\360\000\000b\003G\004\360\000\000G\004h\004\360\000\000h\004i\004\3604\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300a\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033.\250b\260\r\320=O\320Of\320fy\360\000\000z\001P\002\360\000\000P\002h\002\360\000\000h\002|\002\360\000\000|\002}\002\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\032\2302\230T\240\031\250+\260T\270\026\270q\300\t\310\033\320TW\320W]\320]^\320^g\320gt\360\000\000u\001G\002\360\000\000G\002^\002\360\000\000^\002q\002\360\000\000q\002G\003\360\000\000G\003_\003\360\000\000_\003s\003\360\000\000s\003J\004\360\000\000J\004K\004\360\000\000K\004W\004\360\000\000W\004X\004\360\000\000X\004g\004\360\000\000g\004r\004\360\000\000r\004y\004\360\000\000y\004\004\360\000\000\004@\005\360\000\000@\005A\005\330\004\025\220Q\220m\2401\330\004\013\2101"; -static const char __pyx_k_B_aq_Q_T_q_a_r_xr_V82T_Zccddppq[] = "\200\001\340*B\300!\360(\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\026\220r\230\026\230x\240r\250\024\250V\2608\2702\270T\300\034\310]\320Zc\320cd\320dp\320pq\360\000\000r\001A\002\360\000\000A\002B\002\360\000\000B\002C\002\330\004\025\220Q\220i\230q\330\004\013\2101"; -static const char __pyx_k_B_aq_Q_T_q_a_r_xr_V82T_Zddeeqqr[] = "\200\001\340*B\300!\360(\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\026\220r\230\026\230x\240r\250\024\250V\2608\2702\270T\300\034\310]\320Zd\320de\320eq\320qr\360\000\000s\001B\002\360\000\000B\002C\002\360\000\000C\002D\002\330\004\025\220Q\220i\230q\330\004\013\2101"; -static const char __pyx_k_CC_aq_Q_T_q_a_fHBd_m_hhqqrr_O_O[] = "\200\001\340+C\320C[\320[\\\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310m\320[h\320hq\320qr\320r~\320~\360\000\000@\002O\002\360\000\000O\002P\002\360\000\000P\002Q\002\330\004\025\220Q\220j\240\001\330\004\013\2101"; -static const char __pyx_k_CZZqqr_aq_k_6_8_T_7_U_7_A_we_Bl[] = "\200\001\340CZ\320Zq\320qr\360,\000\005\014\210;\220a\220q\330\004\016\210k\230\021\230!\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3007\310!\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033,\250B\250l\270,\300a\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\030\230\022\2304\230y\250\013\2604\260v\270Q\270i\300{\320RY\320Y_\320_`\320`i\320iu\360\000\000v\001B\002\360\000\000B\002K\002\360\000\000K\002L\002\360\000\000L\002X\002\360\000\000X\002Y\002\360\000\000Y\002h\002\360\000\000h\002s\002\360\000\000s\002z\002\360\000\000z\002@\003\360\000\000@\003A\003\360\000\000A\003B\003\330\004\025\220Q\220k\240\021\330\004\013\2101"; -static const char __pyx_k_C_D_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d[] = "\200\001\360\004\000C\002D\002\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0338\270\002\270!\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021%\240R\240t\2509\260K\270t\3006\310\021\310)\320S^\320^b\320bh\320hi\320ir\320r}\360\000\000~\001A\002\360\000\000A\002G\002\360\000\000G\002H\002\360\000\000H\002Q\002\360\000\000Q\002\\\002\360\000\000\\\002a\002\360\000\000a\002g\002\360\000\000g\002h\002\360\000\000h\002q\002\360\000\000q\002\002\360\000\000\002@\003\360\000\000@\003L\003\360\000\000L\003M\003\360\000\000M\003\\\003\360\000\000\\\003d\003\360\000\000d\003n\003\360\000\000n\003t\003\360\000\000t\003u\003\360\000\000u\003v\003\330\004\025\220Q\320\026-\250Q\330\004\013\2101"; -static const char __pyx_k_DD_2_aq_Q_T_q_a_A_6_4vXRt_iixxy[] = "\200\001\340,D\320D\\\320\\]\3602\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\024\220A\330\004\022\220!\330\004\021\220\030\230\022\2306\240\030\250\022\2504\250v\260X\270R\270t\300<\310}\320\\i\320ix\320xy\360\000\000z\001F\002\360\000\000F\002G\002\360\000\000G\002V\002\360\000\000V\002W\002\360\000\000W\002a\002\360\000\000a\002b\002\360\000\000b\002r\002\360\000\000r\002s\002\360\000\000s\002t\002\330\004\025\220Q\220k\240\021\330\004\013\210:\320\025%\240Q"; -static const char __pyx_k_DE_Kq_Kq_7_8_U_E_U_7_A_we_b_q_2[] = "\200\001\340DE\360(\000\005\r\210K\220q\230\001\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2307\240!\330\004\r\210]\230!\2308\240:\250U\260(\270*\300E\310\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033.\250b\260\001\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\032\2302\230T\240\031\250+\260U\270&\300\001\300\031\310+\320UZ\320Z`\320`a\320aj\320jw\320wx\360\000\000y\001E\002\360\000\000E\002F\002\360\000\000F\002U\002\360\000\000U\002`\002\360\000\000`\002g\002\360\000\000g\002m\002\360\000\000m\002n\002\360\000\000n\002o\002\330\004\025\220Q\220m\2401\330\004\013\2101"; -static const char __pyx_k_D_E_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d[] = "\200\001\360\004\000D\002E\002\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0339\270\022\2701\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021&\240b\250\004\250I\260[\300\004\300F\310!\3109\320T_\320_c\320ci\320ij\320js\320s~\360\000\000\001B\002\360\000\000B\002H\002\360\000\000H\002I\002\360\000\000I\002R\002\360\000\000R\002]\002\360\000\000]\002b\002\360\000\000b\002h\002\360\000\000h\002i\002\360\000\000i\002r\002\360\000\000r\002@\003\360\000\000@\003A\003\360\000\000A\003M\003\360\000\000M\003N\003\360\000\000N\003]\003\360\000\000]\003e\003\360\000\000e\003o\003\360\000\000o\003u\003\360\000\000u\003v\003\360\000\000v\003w\003\330\004\025\220Q\320\026.\250a\330\004\013\2101"; -static const char __pyx_k_EQ_aq_Q_T_q_a_a_6_4vXRt_gghhttu[] = "\200\001\340,E\300Q\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\016\210a\330\004\021\220\030\230\022\2306\240\030\250\022\2504\250v\260X\270R\270t\300<\310|\320[g\320gh\320ht\320tu\360\000\000v\001E\002\360\000\000E\002F\002\360\000\000F\002P\002\360\000\000P\002Q\002\360\000\000Q\002R\002\330\004\025\220Q\220k\240\021\330\004\013\210:\220Q"; -static const char __pyx_k_E_F_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d[] = "\200\001\360\004\000E\002F\002\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033:\270\"\270A\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021'\240r\250\024\250Y\260k\300\024\300V\3101\310I\320U`\320`d\320dj\320jk\320kt\320t\360\000\000@\002C\002\360\000\000C\002I\002\360\000\000I\002J\002\360\000\000J\002S\002\360\000\000S\002^\002\360\000\000^\002c\002\360\000\000c\002i\002\360\000\000i\002j\002\360\000\000j\002s\002\360\000\000s\002A\003\360\000\000A\003B\003\360\000\000B\003N\003\360\000\000N\003O\003\360\000\000O\003^\003\360\000\000^\003f\003\360\000\000f\003p\003\360\000\000p\003v\003\360\000\000v\003w\003\360\000\000w\003x\003\330\004\025\220Q\320\026/\250q\330\004\013\2101"; -static const char __pyx_k_E_a_aq_Q_Qa_y_1_6_a_fHBd_kYhhrr[] = "\200\001\340E`\320`a\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\r\210]\230!\2306\240\021\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310k\320Yh\320hr\320rs\320s\360\000\000@\002A\002\360\000\000A\002P\002\360\000\000P\002Q\002\360\000\000Q\002R\002\330\004\025\220Q\220j\240\001\330\004\013\2101"; -static const char __pyx_k_FF_ttu4_aq_Q_T_q_q_q_2V82T_xr_Q[] = "\200\001\340.F\320F]\320]t\320tu\3604\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\027\220q\330\004\030\230\001\330\004\027\220q\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300\\\320Q^\320^h\320hr\320r{\320{|\360\000\000}\001I\002\360\000\000I\002J\002\360\000\000J\002Y\002\360\000\000Y\002Z\002\360\000\000Z\002m\002\360\000\000m\002n\002\360\000\000n\002B\003\360\000\000B\003C\003\360\000\000C\003D\003\330\004\025\220Q\220m\2401\330\004\013\320\013\036\320\0362\260!"; -static const char __pyx_k_Fa_aq_Q_T_q_a_2V82T_xr_Q_ffggss[] = "\200\001\340.F\300a\360(\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300\\\320Q^\320^f\320fg\320gs\320st\360\000\000u\001D\002\360\000\000D\002E\002\360\000\000E\002F\002\330\004\025\220Q\220m\2401\330\004\013\2101"; -static const char __pyx_k_Function__check_opt_input_value[] = "_Function__check_opt_input_value"; -static const char __pyx_k_Function__input_price_series_na[] = "_Function__input_price_series_names"; -static const char __pyx_k_Function_has_an_unstable_period[] = "Function has an unstable period"; -static const char __pyx_k_GGZZr_s_F_F_a_8_aq_Q_T_q_a_A_Bf[] = "\200\001\340/G\320GZ\320Zr\360\000\000s\001F\002\360\000\000F\002`\002\360\000\000`\002a\002\3608\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\024\220A\330\004\022\220!\330\004\021\220\033\230B\230f\240H\250B\250d\260&\270\010\300\002\300$\300l\320R_\320_l\320ly\360\000\000z\001G\002\360\000\000G\002V\002\360\000\000V\002e\002\360\000\000e\002f\002\360\000\000f\002r\002\360\000\000r\002s\002\360\000\000s\002B\003\360\000\000B\003C\003\360\000\000C\003M\003\360\000\000M\003N\003\360\000\000N\003^\003\360\000\000^\003_\003\360\000\000_\003`\003\330\004\025\220Q\220n\240A\330\004\013\210:\320\025%\240Q"; -static const char __pyx_k_GH_aq_Q_Kq_q_6_a_fHBd_m_hhiiuuv[] = "\200\001\340GH\360(\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\021\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310m\320[h\320hi\320iu\320uv\360\000\000w\001F\002\360\000\000F\002G\002\360\000\000G\002H\002\330\004\025\220Q\220j\240\001\330\004\013\2101"; -static const char __pyx_k_GH_aq_Q_Qa_y_1_6_1_F_D_hb_LP_hh[] = "\200\001\340GH\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\r\210]\230!\2306\240\021\330\004\023\2201\330\004\021\220\021\330\004\021\220\031\230\"\230F\240(\250\"\250D\260\006\260h\270b\300\004\300L\320P[\320[h\320hi\320iu\320uv\360\000\000w\001F\002\360\000\000F\002G\002\360\000\000G\002V\002\360\000\000V\002W\002\360\000\000W\002X\002\330\004\025\220Q\220l\240!\330\004\013\210?\230!"; -static const char __pyx_k_IJ_Kq_q_Kq_q_7_a_6_4vXRt_P_jjkk[] = "\200\001\340IJ\360*\000\005\r\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2307\240!\330\004\016\210a\330\004\021\220\030\230\022\2306\240\030\250\022\2504\250v\260X\270R\270t\300=\320P]\320]j\320jk\320kw\320wx\360\000\000y\001H\002\360\000\000H\002I\002\360\000\000I\002J\002\330\004\025\220Q\220k\240\021\330\004\013\2101"; -static const char __pyx_k_IJ_aq_Q_Qa_y_1_6_a_BfHBd_lR_jjk[] = "\200\001\340IJ\360(\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\r\210]\230!\2306\240\021\330\004\016\210a\330\004\021\220\033\230B\230f\240H\250B\250d\260&\270\010\300\002\300$\300l\320R]\320]j\320jk\320kw\320wx\360\000\000y\001H\002\360\000\000H\002I\002\360\000\000I\002J\002\330\004\025\220Q\220n\240A\330\004\013\2101"; -static const char __pyx_k_JK_aq_Q_Qa_y_1_6_a_RvXRt6_4_S_k[] = "\200\001\340JK\360(\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\r\210]\230!\2306\240\021\330\004\016\210a\330\004\021\220\034\230R\230v\240X\250R\250t\2606\270\030\300\022\3004\300|\320S^\320^k\320kl\320lx\320xy\360\000\000z\001I\002\360\000\000I\002J\002\360\000\000J\002K\002\330\004\025\220Q\220o\240Q\330\004\013\2101"; -static const char __pyx_k_Jaaxxy_aq_Q_k_9G1_6_a_6_4vXRt_j[] = "\200\001\340Ja\320ax\320xy\360.\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\016\210k\230\021\230!\330\004\023\2209\230G\2401\330\004\r\210]\230!\2306\240\021\330\004\016\210a\330\004\021\220\030\230\022\2306\240\030\250\022\2504\250v\260X\270R\270t\300<\310\320^j\320jv\320v\360\000\000@\002A\002\360\000\000A\002M\002\360\000\000M\002N\002\360\000\000N\002]\002\360\000\000]\002^\002\360\000\000^\002_\002\330\004\025\220Q\220k\240\021\330\004\013\2101"; -static const char __pyx_k_KL_Kq_q_Kq_q_7_a_2V82T_xr_R__ll[] = "\200\001\340KL\360*\000\005\r\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2307\240!\330\004\016\210a\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300]\320R_\320_l\320lm\320my\320yz\360\000\000{\001J\002\360\000\000J\002K\002\360\000\000K\002L\002\330\004\025\220Q\220m\2401\330\004\013\2101"; -static const char __pyx_k_Kaufman_Adaptive_Moving_Average[] = "Kaufman Adaptive Moving Average"; -static const char __pyx_k_Kq_Kq_7_8_U_E_U_7_A_we_1_q_i_vQ[] = "\200\001\360(\000\005\r\210K\220q\230\001\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2307\240!\330\004\r\210]\230!\2308\240:\250U\260(\270*\300E\310\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2501\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260%\260v\270Q\270i\300{\320RW\320W]\320]^\320^g\320gh\320ht\320tu\360\000\000v\001E\002\360\000\000E\002P\002\360\000\000P\002W\002\360\000\000W\002]\002\360\000\000]\002^\002\360\000\000^\002_\002\330\004\025\220Q\220j\240\001\330\004\013\2101"; -static const char __pyx_k_Kq_Kq_7_8_U_E_U_7_A_we_A_q_4y_5[] = "\200\001\360(\000\005\r\210K\220q\230\001\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2307\240!\330\004\r\210]\230!\2308\240:\250U\260(\270*\300E\310\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033,\250A\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\030\230\022\2304\230y\250\013\2605\270\006\270a\270y\310\013\320SX\320X^\320^_\320_h\320hi\320iu\320uv\360\000\000w\001F\002\360\000\000F\002Q\002\360\000\000Q\002X\002\360\000\000X\002^\002\360\000\000^\002_\002\360\000\000_\002`\002\330\004\025\220Q\220k\240\021\330\004\013\2101"; -static const char __pyx_k_Out_of_Range_Start_Index_TA_OUT[] = "Out-of-Range Start Index (TA_OUT_OF_RANGE_START_INDEX)"; -static const char __pyx_k_Q_AQQVVWWX_Q_5Q_9AT_4q_1JfA_D_R[] = "\200\001\360\014\000\005\022\320\021-\250Q\320.@\300\001\320AQ\320QV\320VW\320WX\330\004\025\220Q\320\0265\260Q\340\004\013\2109\220A\220T\230\021\330\004\013\2104\210q\220\003\2201\220J\230f\240A\330\004\024\220D\230\001\330\004\007\200~\220R\220r\230\023\230B\230d\240$\240f\250B\250a\330\010\030\230\003\2301\230A\340\004\005\330\010\020\220\001\330\010\030\230\t\240\021\240$\240a\330\010\020\220\004\220A\330\010\020\220\t\230\021\230$\230a\330\010\031\230\021\330\010\021\220\021"; -static const char __pyx_k_Q_NeSTTU_Q_2_9AT_4q_1G6_wc_t81H[] = "\200\001\360\014\000\005\022\320\021*\250!\320+=\270Q\320>N\310e\320ST\320TU\330\004\025\220Q\320\0262\260!\340\004\013\2109\220A\220T\230\021\330\004\013\2104\210q\220\003\2201\220G\2306\240\021\330\004\007\200w\210c\220\021\330\010\017\210t\2208\2301\230H\240A\330\t\021\220\023\220A\330\010\017\210q\340\004\005\330\010\020\220\001\330\010\030\230\013\2401\240D\250\010\260\001"; -static const char __pyx_k_SSkk_Y_Y_Z_8_aq_T_q_8_T_U_7_A_w[] = "\200\001\340(@\320@S\320Sk\320k~\360\000\000\001Y\002\360\000\000Y\002Z\002\3608\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033/\250r\260\035\270m\310=\320Xe\320et\320tu\330\004\016\320\016\037\230q\240\010\250\001\330\004\024\320\024%\240Q\240h\250a\330\004\022\320\022#\2401\240H\250A\330\004\021\220\033\230B\230d\240)\250;\260d\270&\300\001\300\031\310-\320Wd\320dq\320q~\360\000\000\001N\002\360\000\000N\002]\002\360\000\000]\002^\002\360\000\000^\002j\002\360\000\000j\002k\002\360\000\000k\002z\002\360\000\000z\002E\003\360\000\000E\003L\003\360\000\000L\003R\003\360\000\000R\003S\003\360\000\000S\003^\003\360\000\000^\003i\003\360\000\000i\003v\003\360\000\000v\003|\003\360\000\000|\003}\003\360\000\000}\003H\004\360\000\000H\004S\004\360\000\000S\004^\004\360\000\000^\004d\004\360\000\000d\004e\004\360\000\000e\004f\004\330\004\025\220Q\220n\240A\330\004\013\210:\320\025%\240Q"; -static const char __pyx_k_TA_RestoreCandleDefaultSettings[] = "TA_RestoreCandleDefaultSettings"; -static const char __pyx_k_TTU_aq_T_q_8_T_U_7_A_we_2_q_q_i[] = "\200\001\340$<\320__pyx_empty_tuple); Py_CLEAR(clear_module_state->__pyx_empty_bytes); Py_CLEAR(clear_module_state->__pyx_empty_unicode); - #ifdef __Pyx_CyFunction_USED - Py_CLEAR(clear_module_state->__pyx_CyFunctionType); - #endif - #ifdef __Pyx_FusedFunction_USED - Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); - #endif #if CYTHON_PEP489_MULTI_PHASE_INIT __Pyx_State_RemoveModule(NULL); #endif @@ -5489,30 +4664,17 @@ static CYTHON_SMALL_CODE int __pyx_m_clear(PyObject *m) { Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_ufunc); for (int i=0; i<10; ++i) { Py_CLEAR(clear_module_state->__pyx_tuple[i]); } for (int i=0; i<369; ++i) { Py_CLEAR(clear_module_state->__pyx_codeobj_tab[i]); } - for (int i=0; i<944; ++i) { Py_CLEAR(clear_module_state->__pyx_string_tab[i]); } - Py_CLEAR(clear_module_state->__pyx_int_0); - Py_CLEAR(clear_module_state->__pyx_int_1); - Py_CLEAR(clear_module_state->__pyx_int_2); - Py_CLEAR(clear_module_state->__pyx_int_3); - Py_CLEAR(clear_module_state->__pyx_int_4); - Py_CLEAR(clear_module_state->__pyx_int_8); - Py_CLEAR(clear_module_state->__pyx_int_9); - Py_CLEAR(clear_module_state->__pyx_int_12); - Py_CLEAR(clear_module_state->__pyx_int_16); - Py_CLEAR(clear_module_state->__pyx_int_32); - Py_CLEAR(clear_module_state->__pyx_int_64); - Py_CLEAR(clear_module_state->__pyx_int_128); - Py_CLEAR(clear_module_state->__pyx_int_256); - Py_CLEAR(clear_module_state->__pyx_int_512); - Py_CLEAR(clear_module_state->__pyx_int_1024); - Py_CLEAR(clear_module_state->__pyx_int_2048); - Py_CLEAR(clear_module_state->__pyx_int_4096); - Py_CLEAR(clear_module_state->__pyx_int_16777216); - Py_CLEAR(clear_module_state->__pyx_int_67108864); - Py_CLEAR(clear_module_state->__pyx_int_134217728); - Py_CLEAR(clear_module_state->__pyx_int_268435456); - Py_CLEAR(clear_module_state->__pyx_int_neg_1); - return 0; + for (int i=0; i<1154; ++i) { Py_CLEAR(clear_module_state->__pyx_string_tab[i]); } + for (int i=0; i<22; ++i) { Py_CLEAR(clear_module_state->__pyx_number_tab[i]); } +/* #### Code section: module_state_clear_contents ### */ +/* CommonTypesMetaclass.module_state_clear */ +Py_CLEAR(clear_module_state->__pyx_CommonTypesMetaclassType); + +/* CythonFunctionShared.module_state_clear */ +Py_CLEAR(clear_module_state->__pyx_CyFunctionType); + +/* #### Code section: module_state_clear_end ### */ +return 0; } #endif /* #### Code section: module_state_traverse ### */ @@ -5526,12 +4688,6 @@ static CYTHON_SMALL_CODE int __pyx_m_traverse(PyObject *m, visitproc visit, void __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_tuple); __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_bytes); __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_unicode); - #ifdef __Pyx_CyFunction_USED - Py_VISIT(traverse_module_state->__pyx_CyFunctionType); - #endif - #ifdef __Pyx_FusedFunction_USED - Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); - #endif Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_4type_type); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_dtype); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_flatiter); @@ -5550,35 +4706,87 @@ static CYTHON_SMALL_CODE int __pyx_m_traverse(PyObject *m, visitproc visit, void Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_ufunc); for (int i=0; i<10; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_tuple[i]); } for (int i=0; i<369; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_codeobj_tab[i]); } - for (int i=0; i<944; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_string_tab[i]); } - __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_0); - __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_1); - __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_2); - __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_3); - __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_4); - __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_8); - __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_9); - __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_12); - __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_16); - __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_32); - __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_64); - __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_128); - __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_256); - __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_512); - __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_1024); - __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_2048); - __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_4096); - __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_16777216); - __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_67108864); - __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_134217728); - __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_268435456); - __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_neg_1); - return 0; + for (int i=0; i<1154; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_string_tab[i]); } + for (int i=0; i<22; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_number_tab[i]); } +/* #### Code section: module_state_traverse_contents ### */ +/* CommonTypesMetaclass.module_state_traverse */ +Py_VISIT(traverse_module_state->__pyx_CommonTypesMetaclassType); + +/* CythonFunctionShared.module_state_traverse */ +Py_VISIT(traverse_module_state->__pyx_CyFunctionType); + +/* #### Code section: module_state_traverse_end ### */ +return 0; } #endif /* #### Code section: module_code ### */ +static CYTHON_INLINE PyTypeObject *__pyx_f_5numpy_5dtype_7typeobj_typeobj(PyArray_Descr *__pyx_v_self) { + PyTypeObject *__pyx_r; + + __pyx_r = PyDataType_TYPEOBJ(__pyx_v_self); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + +static CYTHON_INLINE char __pyx_f_5numpy_5dtype_4kind_kind(PyArray_Descr *__pyx_v_self) { + char __pyx_r; + + __pyx_r = PyDataType_KIND(__pyx_v_self); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + +static CYTHON_INLINE char __pyx_f_5numpy_5dtype_4type_type(PyArray_Descr *__pyx_v_self) { + char __pyx_r; + + __pyx_r = PyDataType_TYPE(__pyx_v_self); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + +static CYTHON_INLINE char __pyx_f_5numpy_5dtype_9byteorder_byteorder(PyArray_Descr *__pyx_v_self) { + char __pyx_r; + + __pyx_r = PyDataType_BYTEORDER(__pyx_v_self); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + +static CYTHON_INLINE int __pyx_f_5numpy_5dtype_8type_num_type_num(PyArray_Descr *__pyx_v_self) { + int __pyx_r; + + __pyx_r = PyDataType_TYPENUM(__pyx_v_self); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + static CYTHON_INLINE npy_intp __pyx_f_5numpy_5dtype_8itemsize_itemsize(PyArray_Descr *__pyx_v_self) { npy_intp __pyx_r; @@ -5860,7 +5068,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 777, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 795, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -5889,7 +5097,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 780, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 798, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -5918,7 +5126,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 783, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 801, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -5947,7 +5155,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 786, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 804, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -5976,7 +5184,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 789, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 807, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -6029,6 +5237,149 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ } +static CYTHON_INLINE int __pyx_f_5numpy_5ufunc_3nin_nin(PyUFuncObject *__pyx_v_self) { + int __pyx_r; + + __pyx_r = _PyUFuncObject_GET_ITEM_DATA(__pyx_v_self)->nin; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + +static CYTHON_INLINE int __pyx_f_5numpy_5ufunc_4nout_nout(PyUFuncObject *__pyx_v_self) { + int __pyx_r; + + __pyx_r = _PyUFuncObject_GET_ITEM_DATA(__pyx_v_self)->nout; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + +static CYTHON_INLINE int __pyx_f_5numpy_5ufunc_5nargs_nargs(PyUFuncObject *__pyx_v_self) { + int __pyx_r; + + __pyx_r = _PyUFuncObject_GET_ITEM_DATA(__pyx_v_self)->nargs; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + +static CYTHON_INLINE PyUFuncGenericFunction *__pyx_f_5numpy_5ufunc_9functions_functions(PyUFuncObject *__pyx_v_self) { + PyUFuncGenericFunction *__pyx_r; + + __pyx_r = _PyUFuncObject_GET_ITEM_DATA(__pyx_v_self)->functions; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + +static CYTHON_INLINE void **__pyx_f_5numpy_5ufunc_4data_data(PyUFuncObject *__pyx_v_self) { + void **__pyx_r; + + __pyx_r = ((void **)_PyUFuncObject_GET_ITEM_DATA(__pyx_v_self)->data); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + +static CYTHON_INLINE int __pyx_f_5numpy_5ufunc_6ntypes_ntypes(PyUFuncObject *__pyx_v_self) { + int __pyx_r; + + __pyx_r = _PyUFuncObject_GET_ITEM_DATA(__pyx_v_self)->ntypes; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + +static CYTHON_INLINE char const *__pyx_f_5numpy_5ufunc_4name_name(PyUFuncObject *__pyx_v_self) { + char const *__pyx_r; + + __pyx_r = _PyUFuncObject_GET_ITEM_DATA(__pyx_v_self)->name; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + +static CYTHON_INLINE char const *__pyx_f_5numpy_5ufunc_3doc_doc(PyUFuncObject *__pyx_v_self) { + char const *__pyx_r; + + __pyx_r = _PyUFuncObject_GET_ITEM_DATA(__pyx_v_self)->doc; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + +static CYTHON_INLINE void *__pyx_f_5numpy_5ufunc_3ptr_ptr(PyUFuncObject *__pyx_v_self) { + void *__pyx_r; + + __pyx_r = _PyUFuncObject_GET_ITEM_DATA(__pyx_v_self)->ptr; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_5ufunc_3obj_obj(PyUFuncObject *__pyx_v_self) { + PyObject *__pyx_r; + + __pyx_r = _PyUFuncObject_GET_ITEM_DATA(__pyx_v_self)->obj; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_5ufunc_9userloops_userloops(PyUFuncObject *__pyx_v_self) { + PyObject *__pyx_r; + + __pyx_r = _PyUFuncObject_GET_ITEM_DATA(__pyx_v_self)->userloops; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + + static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { int __pyx_t_1; int __pyx_lineno = 0; @@ -6037,7 +5388,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a Py_INCREF(__pyx_v_base); - __pyx_t_1 = PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(3, 996, __pyx_L1_error) + __pyx_t_1 = PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(3, 1067, __pyx_L1_error) /* function exit code */ @@ -6092,8 +5443,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; - PyObject *__pyx_t_10 = NULL; - size_t __pyx_t_11; + size_t __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -6108,7 +5458,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { - __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(3, 1008, __pyx_L3_error) + __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(3, 1079, __pyx_L3_error) } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -6120,26 +5470,23 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(3, 1009, __pyx_L5_except_error) + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(3, 1080, __pyx_L5_except_error) __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_7); __pyx_t_9 = NULL; - __Pyx_INCREF(__pyx_builtin_ImportError); - __pyx_t_10 = __pyx_builtin_ImportError; - __pyx_t_11 = 1; + __pyx_t_10 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_mstate_global->__pyx_kp_u_numpy__core_multiarray_failed_to}; - __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ImportError)), __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1010, __pyx_L5_except_error) + if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1081, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); } __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(3, 1010, __pyx_L5_except_error) + __PYX_ERR(3, 1081, __pyx_L5_except_error) } goto __pyx_L5_except_error; @@ -6162,7 +5509,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); - __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; @@ -6183,8 +5529,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; - PyObject *__pyx_t_10 = NULL; - size_t __pyx_t_11; + size_t __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -6199,7 +5544,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(3, 1014, __pyx_L3_error) + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(3, 1085, __pyx_L3_error) } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -6211,26 +5556,23 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(3, 1015, __pyx_L5_except_error) + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(3, 1086, __pyx_L5_except_error) __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_7); __pyx_t_9 = NULL; - __Pyx_INCREF(__pyx_builtin_ImportError); - __pyx_t_10 = __pyx_builtin_ImportError; - __pyx_t_11 = 1; + __pyx_t_10 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_mstate_global->__pyx_kp_u_numpy__core_umath_failed_to_impo}; - __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ImportError)), __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1016, __pyx_L5_except_error) + if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1087, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); } __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(3, 1016, __pyx_L5_except_error) + __PYX_ERR(3, 1087, __pyx_L5_except_error) } goto __pyx_L5_except_error; @@ -6253,7 +5595,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); - __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; @@ -6274,8 +5615,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; - PyObject *__pyx_t_10 = NULL; - size_t __pyx_t_11; + size_t __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -6290,7 +5630,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(3, 1020, __pyx_L3_error) + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(3, 1091, __pyx_L3_error) } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -6302,26 +5642,23 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(3, 1021, __pyx_L5_except_error) + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(3, 1092, __pyx_L5_except_error) __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_7); __pyx_t_9 = NULL; - __Pyx_INCREF(__pyx_builtin_ImportError); - __pyx_t_10 = __pyx_builtin_ImportError; - __pyx_t_11 = 1; + __pyx_t_10 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_mstate_global->__pyx_kp_u_numpy__core_umath_failed_to_impo}; - __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ImportError)), __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1022, __pyx_L5_except_error) + if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1093, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); } __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(3, 1022, __pyx_L5_except_error) + __PYX_ERR(3, 1093, __pyx_L5_except_error) } goto __pyx_L5_except_error; @@ -6344,7 +5681,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); - __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; @@ -6382,7 +5718,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_o static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject *__pyx_v_obj) { npy_datetime __pyx_r; - __pyx_r = ((PyDatetimeScalarObject *)__pyx_v_obj)->obval; + __pyx_r = _PyDatetimeScalarObject_GetValue(__pyx_v_obj); goto __pyx_L0; @@ -6395,7 +5731,7 @@ static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject * static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject *__pyx_v_obj) { npy_timedelta __pyx_r; - __pyx_r = ((PyTimedeltaScalarObject *)__pyx_v_obj)->obval; + __pyx_r = _PyTimedeltaScalarObject_GetValue(__pyx_v_obj); goto __pyx_L0; @@ -6408,7 +5744,7 @@ static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObject *__pyx_v_obj) { NPY_DATETIMEUNIT __pyx_r; - __pyx_r = ((NPY_DATETIMEUNIT)((PyDatetimeScalarObject *)__pyx_v_obj)->obmeta.base); + __pyx_r = _PyDatetimeScalarObject_GetMetadata(__pyx_v_obj).base; goto __pyx_L0; @@ -6433,10 +5769,9 @@ static PyObject *__pyx_f_5talib_7_ta_lib__ta_check_success(PyObject *__pyx_v_fun PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_5[5]; PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7[5]; - size_t __pyx_t_8; + size_t __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -6567,34 +5902,28 @@ static PyObject *__pyx_f_5talib_7_ta_lib__ta_check_success(PyObject *__pyx_v_fun } __pyx_t_2 = NULL; - __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception))); - __pyx_t_3 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); - __pyx_t_4 = __Pyx_PyUnicode_Unicode(__pyx_v_function_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 48, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Unicode(__pyx_v_function_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyUnicode_From_TA_RetCode(__pyx_v_ret_code, 0, ' ', 'd'); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 48, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyLong_From_TA_RetCode(__pyx_v_ret_code); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 48, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_t_5), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 48, __pyx_L1_error) + __pyx_t_5[0] = __pyx_t_3; + __pyx_t_5[1] = __pyx_mstate_global->__pyx_kp_u_function_failed_with_error_code; + __pyx_t_5[2] = __pyx_t_4; + __pyx_t_5[3] = __pyx_mstate_global->__pyx_kp_u_; + __pyx_t_5[4] = __pyx_v_description; + + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_5, 5, __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 33 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_v_description), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_v_description)); + if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 47, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_7[0] = __pyx_t_4; - __pyx_t_7[1] = __pyx_mstate_global->__pyx_kp_u_function_failed_with_error_code; - __pyx_t_7[2] = __pyx_t_6; - __pyx_t_7[3] = __pyx_mstate_global->__pyx_kp_u_; - __pyx_t_7[4] = __pyx_v_description; - - __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_7, 5, __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + 33 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_v_description), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_v_description)); - if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 47, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_8 = 1; + __pyx_t_7 = 1; { - PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_5}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_Exception)), __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 47, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } @@ -6609,7 +5938,6 @@ static PyObject *__pyx_f_5talib_7_ta_lib__ta_check_success(PyObject *__pyx_v_fun __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("talib._ta_lib._ta_check_success", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; @@ -6661,7 +5989,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_function_name,&__pyx_mstate_global->__pyx_n_u_ret_code,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 6, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 6, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -6676,7 +6004,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_check_success", 0) < 0) __PYX_ERR(1, 6, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_check_success", 0) < (0)) __PYX_ERR(1, 6, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_ta_check_success", 1, 2, 2, i); __PYX_ERR(1, 6, __pyx_L3_error) } } @@ -6887,7 +6215,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 63, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 63, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -6898,7 +6226,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < 0) __PYX_ERR(1, 63, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < (0)) __PYX_ERR(1, 63, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, i); __PYX_ERR(1, 63, __pyx_L3_error) } } @@ -6951,7 +6279,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_7MA_Type___init__(CYTHON_UNUSED PyObje __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_SMA); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 65, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Simple_Moving_Average) < 0) __PYX_ERR(1, 65, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Simple_Moving_Average) < (0)) __PYX_ERR(1, 65, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 66, __pyx_L1_error) @@ -6959,7 +6287,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_7MA_Type___init__(CYTHON_UNUSED PyObje __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_EMA); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 66, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Exponential_Moving_Average) < 0) __PYX_ERR(1, 65, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Exponential_Moving_Average) < (0)) __PYX_ERR(1, 65, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 67, __pyx_L1_error) @@ -6967,7 +6295,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_7MA_Type___init__(CYTHON_UNUSED PyObje __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_WMA); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 67, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Weighted_Moving_Average) < 0) __PYX_ERR(1, 65, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Weighted_Moving_Average) < (0)) __PYX_ERR(1, 65, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 68, __pyx_L1_error) @@ -6975,7 +6303,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_7MA_Type___init__(CYTHON_UNUSED PyObje __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DEMA); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Double_Exponential_Moving_Averag) < 0) __PYX_ERR(1, 65, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Double_Exponential_Moving_Averag) < (0)) __PYX_ERR(1, 65, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 69, __pyx_L1_error) @@ -6983,7 +6311,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_7MA_Type___init__(CYTHON_UNUSED PyObje __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_TEMA); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 69, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Triple_Exponential_Moving_Averag) < 0) __PYX_ERR(1, 65, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Triple_Exponential_Moving_Averag) < (0)) __PYX_ERR(1, 65, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 70, __pyx_L1_error) @@ -6991,7 +6319,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_7MA_Type___init__(CYTHON_UNUSED PyObje __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_TRIMA); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 70, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Triangular_Moving_Average) < 0) __PYX_ERR(1, 65, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Triangular_Moving_Average) < (0)) __PYX_ERR(1, 65, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 71, __pyx_L1_error) @@ -6999,7 +6327,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_7MA_Type___init__(CYTHON_UNUSED PyObje __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_KAMA); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Kaufman_Adaptive_Moving_Average) < 0) __PYX_ERR(1, 65, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Kaufman_Adaptive_Moving_Average) < (0)) __PYX_ERR(1, 65, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 72, __pyx_L1_error) @@ -7007,7 +6335,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_7MA_Type___init__(CYTHON_UNUSED PyObje __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MAMA); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 72, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_mstate_global->__pyx_kp_u_MESA_Adaptive_Moving_Average) < 0) __PYX_ERR(1, 65, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_mstate_global->__pyx_kp_u_MESA_Adaptive_Moving_Average) < (0)) __PYX_ERR(1, 65, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 73, __pyx_L1_error) @@ -7015,10 +6343,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_7MA_Type___init__(CYTHON_UNUSED PyObje __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_T3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 73, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Triple_Generalized_Double_Expone) < 0) __PYX_ERR(1, 65, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Triple_Generalized_Double_Expone) < (0)) __PYX_ERR(1, 65, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lookup, __pyx_t_1) < 0) __PYX_ERR(1, 64, __pyx_L1_error) + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lookup, __pyx_t_1) < (0)) __PYX_ERR(1, 64, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -7079,7 +6407,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_type,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 76, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 76, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -7094,7 +6422,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__getitem__", 0) < 0) __PYX_ERR(1, 76, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__getitem__", 0) < (0)) __PYX_ERR(1, 76, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__getitem__", 1, 2, 2, i); __PYX_ERR(1, 76, __pyx_L3_error) } } @@ -7207,7 +6535,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_name,&__pyx_mstate_global->__pyx_n_u_period,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 90, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 90, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -7222,7 +6550,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_set_unstable_period", 0) < 0) __PYX_ERR(1, 90, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_set_unstable_period", 0) < (0)) __PYX_ERR(1, 90, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_ta_set_unstable_period", 1, 2, 2, i); __PYX_ERR(1, 90, __pyx_L3_error) } } @@ -7346,7 +6674,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_name,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 96, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 96, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -7357,7 +6685,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_get_unstable_period", 0) < 0) __PYX_ERR(1, 96, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_get_unstable_period", 0) < (0)) __PYX_ERR(1, 96, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_ta_get_unstable_period", 1, 1, 1, i); __PYX_ERR(1, 96, __pyx_L3_error) } } @@ -7477,7 +6805,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_value,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 102, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 102, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -7488,7 +6816,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_set_compatibility", 0) < 0) __PYX_ERR(1, 102, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_set_compatibility", 0) < (0)) __PYX_ERR(1, 102, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_ta_set_compatibility", 1, 1, 1, i); __PYX_ERR(1, 102, __pyx_L3_error) } } @@ -7648,7 +6976,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_settingtype,&__pyx_mstate_global->__pyx_n_u_rangetype,&__pyx_mstate_global->__pyx_n_u_avgperiod,&__pyx_mstate_global->__pyx_n_u_factor,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 124, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 124, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -7671,7 +6999,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_set_candle_settings", 0) < 0) __PYX_ERR(1, 124, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_set_candle_settings", 0) < (0)) __PYX_ERR(1, 124, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_ta_set_candle_settings", 1, 4, 4, i); __PYX_ERR(1, 124, __pyx_L3_error) } } @@ -7794,7 +7122,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_settingtype,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 129, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 129, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -7805,7 +7133,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_restore_candle_default_settings", 0) < 0) __PYX_ERR(1, 129, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_restore_candle_default_settings", 0) < (0)) __PYX_ERR(1, 129, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_ta_restore_candle_default_settings", 1, 1, 1, i); __PYX_ERR(1, 129, __pyx_L3_error) } } @@ -7879,8 +7207,7 @@ static PyArrayObject *__pyx_f_5talib_7_ta_lib_check_array(PyArrayObject *__pyx_v int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - size_t __pyx_t_5; + size_t __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -7891,14 +7218,11 @@ static PyArrayObject *__pyx_f_5talib_7_ta_lib_check_array(PyArrayObject *__pyx_v if (unlikely(__pyx_t_1)) { __pyx_t_3 = NULL; - __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception))); - __pyx_t_4 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); - __pyx_t_5 = 1; + __pyx_t_4 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_input_array_type_is_not_double}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_Exception)), __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 22, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } @@ -7911,15 +7235,12 @@ static PyArrayObject *__pyx_f_5talib_7_ta_lib_check_array(PyArrayObject *__pyx_v __pyx_t_1 = (__pyx_f_5numpy_7ndarray_4ndim_ndim(__pyx_v_real) != 1); if (unlikely(__pyx_t_1)) { - __pyx_t_4 = NULL; - __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception))); - __pyx_t_3 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); - __pyx_t_5 = 1; + __pyx_t_3 = NULL; + __pyx_t_4 = 1; { - PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_input_array_has_wrong_dimensions}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_input_array_has_wrong_dimensions}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_Exception)), __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 24, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } @@ -7949,7 +7270,6 @@ static PyArrayObject *__pyx_f_5talib_7_ta_lib_check_array(PyArrayObject *__pyx_v __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("talib._ta_lib.check_array", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; @@ -7967,8 +7287,7 @@ static npy_intp __pyx_f_5talib_7_ta_lib_check_length2(PyArrayObject *__pyx_v_a1, int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - size_t __pyx_t_5; + size_t __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -7980,14 +7299,11 @@ static npy_intp __pyx_f_5talib_7_ta_lib_check_length2(PyArrayObject *__pyx_v_a1, if (unlikely(__pyx_t_1)) { __pyx_t_3 = NULL; - __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception))); - __pyx_t_4 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); - __pyx_t_5 = 1; + __pyx_t_4 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_input_array_lengths_are_differen}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_Exception)), __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 34, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } @@ -8005,9 +7321,8 @@ static npy_intp __pyx_f_5talib_7_ta_lib_check_length2(PyArrayObject *__pyx_v_a1, __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("talib._ta_lib.check_length2", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; + __pyx_r = -1L; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -8021,8 +7336,7 @@ static npy_intp __pyx_f_5talib_7_ta_lib_check_length3(PyArrayObject *__pyx_v_a1, int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - size_t __pyx_t_5; + size_t __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -8034,14 +7348,11 @@ static npy_intp __pyx_f_5talib_7_ta_lib_check_length3(PyArrayObject *__pyx_v_a1, if (unlikely(__pyx_t_1)) { __pyx_t_3 = NULL; - __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception))); - __pyx_t_4 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); - __pyx_t_5 = 1; + __pyx_t_4 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_input_array_lengths_are_differen}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_Exception)), __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 42, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } @@ -8054,15 +7365,12 @@ static npy_intp __pyx_f_5talib_7_ta_lib_check_length3(PyArrayObject *__pyx_v_a1, __pyx_t_1 = (__pyx_v_length != (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a3)[0])); if (unlikely(__pyx_t_1)) { - __pyx_t_4 = NULL; - __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception))); - __pyx_t_3 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); - __pyx_t_5 = 1; + __pyx_t_3 = NULL; + __pyx_t_4 = 1; { - PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_input_array_lengths_are_differen}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_input_array_lengths_are_differen}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_Exception)), __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 44, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } @@ -8080,9 +7388,8 @@ static npy_intp __pyx_f_5talib_7_ta_lib_check_length3(PyArrayObject *__pyx_v_a1, __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("talib._ta_lib.check_length3", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; + __pyx_r = -1L; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -8096,8 +7403,7 @@ static npy_intp __pyx_f_5talib_7_ta_lib_check_length4(PyArrayObject *__pyx_v_a1, int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - size_t __pyx_t_5; + size_t __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -8109,14 +7415,11 @@ static npy_intp __pyx_f_5talib_7_ta_lib_check_length4(PyArrayObject *__pyx_v_a1, if (unlikely(__pyx_t_1)) { __pyx_t_3 = NULL; - __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception))); - __pyx_t_4 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); - __pyx_t_5 = 1; + __pyx_t_4 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_input_array_lengths_are_differen}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_Exception)), __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 52, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } @@ -8129,15 +7432,12 @@ static npy_intp __pyx_f_5talib_7_ta_lib_check_length4(PyArrayObject *__pyx_v_a1, __pyx_t_1 = (__pyx_v_length != (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a3)[0])); if (unlikely(__pyx_t_1)) { - __pyx_t_4 = NULL; - __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception))); - __pyx_t_3 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); - __pyx_t_5 = 1; + __pyx_t_3 = NULL; + __pyx_t_4 = 1; { - PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_input_array_lengths_are_differen}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_input_array_lengths_are_differen}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_Exception)), __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 54, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } @@ -8151,14 +7451,11 @@ static npy_intp __pyx_f_5talib_7_ta_lib_check_length4(PyArrayObject *__pyx_v_a1, if (unlikely(__pyx_t_1)) { __pyx_t_3 = NULL; - __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception))); - __pyx_t_4 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); - __pyx_t_5 = 1; + __pyx_t_4 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_input_array_lengths_are_differen}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_Exception)), __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 56, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } @@ -8176,9 +7473,8 @@ static npy_intp __pyx_f_5talib_7_ta_lib_check_length4(PyArrayObject *__pyx_v_a1, __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("talib._ta_lib.check_length4", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; + __pyx_r = -1L; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -8503,7 +7799,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_18ACCBANDS, "ACCBANDS(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\nACCBANDS(high, low, close[, timeperiod=?])\n\nAcceleration Bands (Overlap Studies)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 20\nOutputs:\n upperband\n middleband\n lowerband"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_18ACCBANDS, "ACCBANDS(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nACCBANDS(high, low, close[, timeperiod=?])\n\nAcceleration Bands (Overlap Studies)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 20\nOutputs:\n upperband\n middleband\n lowerband"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_19ACCBANDS = {"ACCBANDS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_19ACCBANDS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_18ACCBANDS}; static PyObject *__pyx_pw_5talib_7_ta_lib_19ACCBANDS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -8538,7 +7834,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 142, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 142, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -8561,7 +7857,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ACCBANDS", 0) < 0) __PYX_ERR(4, 142, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ACCBANDS", 0) < (0)) __PYX_ERR(4, 142, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ACCBANDS", 0, 3, 4, i); __PYX_ERR(4, 142, __pyx_L3_error) } } @@ -8665,7 +7961,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_18ACCBANDS(CYTHON_UNUSED PyObject *__p __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 170, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 170, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 171, __pyx_L1_error) @@ -8739,7 +8035,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_20ACOS, "ACOS(ndarray real)\nACOS(real)\n\nVector Trigonometric ACos (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_20ACOS, "ACOS(ndarray real)\n\nACOS(real)\n\nVector Trigonometric ACos (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_21ACOS = {"ACOS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_21ACOS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_20ACOS}; static PyObject *__pyx_pw_5talib_7_ta_lib_21ACOS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -8771,7 +8067,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 181, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 181, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -8782,7 +8078,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ACOS", 0) < 0) __PYX_ERR(4, 181, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ACOS", 0) < (0)) __PYX_ERR(4, 181, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ACOS", 1, 1, 1, i); __PYX_ERR(4, 181, __pyx_L3_error) } } @@ -8899,7 +8195,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_22AD, "AD(ndarray high, ndarray low, ndarray close, ndarray volume)\nAD(high, low, close, volume)\n\nChaikin A/D Line (Volume Indicators)\n\nInputs:\n prices: ['high', 'low', 'close', 'volume']\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_22AD, "AD(ndarray high, ndarray low, ndarray close, ndarray volume)\n\nAD(high, low, close, volume)\n\nChaikin A/D Line (Volume Indicators)\n\nInputs:\n prices: ['high', 'low', 'close', 'volume']\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_23AD = {"AD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_23AD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_22AD}; static PyObject *__pyx_pw_5talib_7_ta_lib_23AD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -8934,7 +8230,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_volume,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 210, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 210, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -8957,7 +8253,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "AD", 0) < 0) __PYX_ERR(4, 210, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "AD", 0) < (0)) __PYX_ERR(4, 210, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("AD", 1, 4, 4, i); __PYX_ERR(4, 210, __pyx_L3_error) } } @@ -9057,7 +8353,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_22AD(CYTHON_UNUSED PyObject *__pyx_sel __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 233, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 233, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 234, __pyx_L1_error) @@ -9109,7 +8405,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_24ADD, "ADD(ndarray real0, ndarray real1)\nADD(real0, real1)\n\nVector Arithmetic Add (Math Operators)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_24ADD, "ADD(ndarray real0, ndarray real1)\n\nADD(real0, real1)\n\nVector Arithmetic Add (Math Operators)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_25ADD = {"ADD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_25ADD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_24ADD}; static PyObject *__pyx_pw_5talib_7_ta_lib_25ADD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -9142,7 +8438,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 242, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 242, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -9157,7 +8453,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ADD", 0) < 0) __PYX_ERR(4, 242, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ADD", 0) < (0)) __PYX_ERR(4, 242, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ADD", 1, 2, 2, i); __PYX_ERR(4, 242, __pyx_L3_error) } } @@ -9237,7 +8533,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_24ADD(CYTHON_UNUSED PyObject *__pyx_se __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 264, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 264, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 265, __pyx_L1_error) @@ -9287,7 +8583,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_26ADOSC, "ADOSC(ndarray high, ndarray low, ndarray close, ndarray volume, int fastperiod=-0x80000000, int slowperiod=-0x80000000)\nADOSC(high, low, close, volume[, fastperiod=?, slowperiod=?])\n\nChaikin A/D Oscillator (Volume Indicators)\n\nInputs:\n prices: ['high', 'low', 'close', 'volume']\nParameters:\n fastperiod: 3\n slowperiod: 10\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_26ADOSC, "ADOSC(ndarray high, ndarray low, ndarray close, ndarray volume, int fastperiod=-0x80000000, int slowperiod=-0x80000000)\n\nADOSC(high, low, close, volume[, fastperiod=?, slowperiod=?])\n\nChaikin A/D Oscillator (Volume Indicators)\n\nInputs:\n prices: ['high', 'low', 'close', 'volume']\nParameters:\n fastperiod: 3\n slowperiod: 10\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_27ADOSC = {"ADOSC", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_27ADOSC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_26ADOSC}; static PyObject *__pyx_pw_5talib_7_ta_lib_27ADOSC(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -9324,7 +8620,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_volume,&__pyx_mstate_global->__pyx_n_u_fastperiod,&__pyx_mstate_global->__pyx_n_u_slowperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 273, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 273, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 6: @@ -9355,7 +8651,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ADOSC", 0) < 0) __PYX_ERR(4, 273, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ADOSC", 0) < (0)) __PYX_ERR(4, 273, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ADOSC", 0, 4, 6, i); __PYX_ERR(4, 273, __pyx_L3_error) } } @@ -9476,7 +8772,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_26ADOSC(CYTHON_UNUSED PyObject *__pyx_ __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 299, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 299, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 300, __pyx_L1_error) @@ -9528,7 +8824,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_28ADX, "ADX(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\nADX(high, low, close[, timeperiod=?])\n\nAverage Directional Movement Index (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_28ADX, "ADX(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nADX(high, low, close[, timeperiod=?])\n\nAverage Directional Movement Index (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_29ADX = {"ADX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_29ADX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_28ADX}; static PyObject *__pyx_pw_5talib_7_ta_lib_29ADX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -9563,7 +8859,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 308, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 308, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -9586,7 +8882,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ADX", 0) < 0) __PYX_ERR(4, 308, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ADX", 0) < (0)) __PYX_ERR(4, 308, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ADX", 0, 3, 4, i); __PYX_ERR(4, 308, __pyx_L3_error) } } @@ -9688,7 +8984,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_28ADX(CYTHON_UNUSED PyObject *__pyx_se __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 332, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 332, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 333, __pyx_L1_error) @@ -9739,7 +9035,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_30ADXR, "ADXR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\nADXR(high, low, close[, timeperiod=?])\n\nAverage Directional Movement Index Rating (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_30ADXR, "ADXR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nADXR(high, low, close[, timeperiod=?])\n\nAverage Directional Movement Index Rating (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_31ADXR = {"ADXR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_31ADXR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_30ADXR}; static PyObject *__pyx_pw_5talib_7_ta_lib_31ADXR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -9774,7 +9070,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 341, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 341, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -9797,7 +9093,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ADXR", 0) < 0) __PYX_ERR(4, 341, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ADXR", 0) < (0)) __PYX_ERR(4, 341, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ADXR", 0, 3, 4, i); __PYX_ERR(4, 341, __pyx_L3_error) } } @@ -9899,7 +9195,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_30ADXR(CYTHON_UNUSED PyObject *__pyx_s __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 365, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 365, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 366, __pyx_L1_error) @@ -9950,7 +9246,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_32APO, "APO(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int matype=0)\nAPO(real[, fastperiod=?, slowperiod=?, matype=?])\n\nAbsolute Price Oscillator (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n fastperiod: 12\n slowperiod: 26\n matype: 0 (Simple Moving Average)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_32APO, "APO(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int matype=0)\n\nAPO(real[, fastperiod=?, slowperiod=?, matype=?])\n\nAbsolute Price Oscillator (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n fastperiod: 12\n slowperiod: 26\n matype: 0 (Simple Moving Average)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_33APO = {"APO", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_33APO, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_32APO}; static PyObject *__pyx_pw_5talib_7_ta_lib_33APO(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -9985,7 +9281,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_fastperiod,&__pyx_mstate_global->__pyx_n_u_slowperiod,&__pyx_mstate_global->__pyx_n_u_matype,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 374, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 374, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -10008,7 +9304,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "APO", 0) < 0) __PYX_ERR(4, 374, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "APO", 0) < (0)) __PYX_ERR(4, 374, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("APO", 0, 1, 4, i); __PYX_ERR(4, 374, __pyx_L3_error) } } @@ -10155,7 +9451,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_34AROON, "AROON(ndarray high, ndarray low, int timeperiod=-0x80000000)\nAROON(high, low[, timeperiod=?])\n\nAroon (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n timeperiod: 14\nOutputs:\n aroondown\n aroonup"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_34AROON, "AROON(ndarray high, ndarray low, int timeperiod=-0x80000000)\n\nAROON(high, low[, timeperiod=?])\n\nAroon (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n timeperiod: 14\nOutputs:\n aroondown\n aroonup"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_35AROON = {"AROON", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_35AROON, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_34AROON}; static PyObject *__pyx_pw_5talib_7_ta_lib_35AROON(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -10189,7 +9485,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 407, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 407, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -10208,7 +9504,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "AROON", 0) < 0) __PYX_ERR(4, 407, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "AROON", 0) < (0)) __PYX_ERR(4, 407, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("AROON", 0, 2, 3, i); __PYX_ERR(4, 407, __pyx_L3_error) } } @@ -10301,7 +9597,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_34AROON(CYTHON_UNUSED PyObject *__pyx_ __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 432, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 432, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 433, __pyx_L1_error) @@ -10365,7 +9661,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_36AROONOSC, "AROONOSC(ndarray high, ndarray low, int timeperiod=-0x80000000)\nAROONOSC(high, low[, timeperiod=?])\n\nAroon Oscillator (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_36AROONOSC, "AROONOSC(ndarray high, ndarray low, int timeperiod=-0x80000000)\n\nAROONOSC(high, low[, timeperiod=?])\n\nAroon Oscillator (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_37AROONOSC = {"AROONOSC", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_37AROONOSC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_36AROONOSC}; static PyObject *__pyx_pw_5talib_7_ta_lib_37AROONOSC(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -10399,7 +9695,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 442, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 442, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -10418,7 +9714,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "AROONOSC", 0) < 0) __PYX_ERR(4, 442, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "AROONOSC", 0) < (0)) __PYX_ERR(4, 442, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("AROONOSC", 0, 2, 3, i); __PYX_ERR(4, 442, __pyx_L3_error) } } @@ -10510,7 +9806,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_36AROONOSC(CYTHON_UNUSED PyObject *__p __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 465, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 465, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 466, __pyx_L1_error) @@ -10560,7 +9856,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_38ASIN, "ASIN(ndarray real)\nASIN(real)\n\nVector Trigonometric ASin (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_38ASIN, "ASIN(ndarray real)\n\nASIN(real)\n\nVector Trigonometric ASin (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_39ASIN = {"ASIN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_39ASIN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_38ASIN}; static PyObject *__pyx_pw_5talib_7_ta_lib_39ASIN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -10592,7 +9888,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 474, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 474, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -10603,7 +9899,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ASIN", 0) < 0) __PYX_ERR(4, 474, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ASIN", 0) < (0)) __PYX_ERR(4, 474, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ASIN", 1, 1, 1, i); __PYX_ERR(4, 474, __pyx_L3_error) } } @@ -10720,7 +10016,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_40ATAN, "ATAN(ndarray real)\nATAN(real)\n\nVector Trigonometric ATan (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_40ATAN, "ATAN(ndarray real)\n\nATAN(real)\n\nVector Trigonometric ATan (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_41ATAN = {"ATAN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_41ATAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_40ATAN}; static PyObject *__pyx_pw_5talib_7_ta_lib_41ATAN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -10752,7 +10048,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 503, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 503, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -10763,7 +10059,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ATAN", 0) < 0) __PYX_ERR(4, 503, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ATAN", 0) < (0)) __PYX_ERR(4, 503, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ATAN", 1, 1, 1, i); __PYX_ERR(4, 503, __pyx_L3_error) } } @@ -10880,7 +10176,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_42ATR, "ATR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\nATR(high, low, close[, timeperiod=?])\n\nAverage True Range (Volatility Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_42ATR, "ATR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nATR(high, low, close[, timeperiod=?])\n\nAverage True Range (Volatility Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_43ATR = {"ATR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_43ATR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_42ATR}; static PyObject *__pyx_pw_5talib_7_ta_lib_43ATR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -10915,7 +10211,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 532, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 532, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -10938,7 +10234,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ATR", 0) < 0) __PYX_ERR(4, 532, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ATR", 0) < (0)) __PYX_ERR(4, 532, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ATR", 0, 3, 4, i); __PYX_ERR(4, 532, __pyx_L3_error) } } @@ -11040,7 +10336,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_42ATR(CYTHON_UNUSED PyObject *__pyx_se __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 556, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 556, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 557, __pyx_L1_error) @@ -11091,7 +10387,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_44AVGPRICE, "AVGPRICE(ndarray open, ndarray high, ndarray low, ndarray close)\nAVGPRICE(open, high, low, close)\n\nAverage Price (Price Transform)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_44AVGPRICE, "AVGPRICE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nAVGPRICE(open, high, low, close)\n\nAverage Price (Price Transform)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_45AVGPRICE = {"AVGPRICE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_45AVGPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_44AVGPRICE}; static PyObject *__pyx_pw_5talib_7_ta_lib_45AVGPRICE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -11126,7 +10422,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 565, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 565, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -11149,7 +10445,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "AVGPRICE", 0) < 0) __PYX_ERR(4, 565, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "AVGPRICE", 0) < (0)) __PYX_ERR(4, 565, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("AVGPRICE", 1, 4, 4, i); __PYX_ERR(4, 565, __pyx_L3_error) } } @@ -11249,7 +10545,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_44AVGPRICE(CYTHON_UNUSED PyObject *__p __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 588, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 588, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 589, __pyx_L1_error) @@ -11301,7 +10597,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_46AVGDEV, "AVGDEV(ndarray real, int timeperiod=-0x80000000)\nAVGDEV(real[, timeperiod=?])\n\nAverage Deviation (Price Transform)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_46AVGDEV, "AVGDEV(ndarray real, int timeperiod=-0x80000000)\n\nAVGDEV(real[, timeperiod=?])\n\nAverage Deviation (Price Transform)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_47AVGDEV = {"AVGDEV", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_47AVGDEV, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_46AVGDEV}; static PyObject *__pyx_pw_5talib_7_ta_lib_47AVGDEV(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -11334,7 +10630,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 597, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 597, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -11349,7 +10645,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "AVGDEV", 0) < 0) __PYX_ERR(4, 597, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "AVGDEV", 0) < (0)) __PYX_ERR(4, 597, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("AVGDEV", 0, 1, 2, i); __PYX_ERR(4, 597, __pyx_L3_error) } } @@ -11478,7 +10774,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_48BBANDS, "BBANDS(ndarray real, int timeperiod=-0x80000000, double nbdevup=-4e37, double nbdevdn=-4e37, int matype=0)\nBBANDS(real[, timeperiod=?, nbdevup=?, nbdevdn=?, matype=?])\n\nBollinger Bands (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 5\n nbdevup: 2.0\n nbdevdn: 2.0\n matype: 0 (Simple Moving Average)\nOutputs:\n upperband\n middleband\n lowerband"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_48BBANDS, "BBANDS(ndarray real, int timeperiod=-0x80000000, double nbdevup=-4e37, double nbdevdn=-4e37, int matype=0)\n\nBBANDS(real[, timeperiod=?, nbdevup=?, nbdevdn=?, matype=?])\n\nBollinger Bands (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 5\n nbdevup: 2.0\n nbdevdn: 2.0\n matype: 0 (Simple Moving Average)\nOutputs:\n upperband\n middleband\n lowerband"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_49BBANDS = {"BBANDS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_49BBANDS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_48BBANDS}; static PyObject *__pyx_pw_5talib_7_ta_lib_49BBANDS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -11514,7 +10810,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_nbdevup,&__pyx_mstate_global->__pyx_n_u_nbdevdn,&__pyx_mstate_global->__pyx_n_u_matype,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 628, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 628, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 5: @@ -11541,7 +10837,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "BBANDS", 0) < 0) __PYX_ERR(4, 628, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "BBANDS", 0) < (0)) __PYX_ERR(4, 628, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("BBANDS", 0, 1, 5, i); __PYX_ERR(4, 628, __pyx_L3_error) } } @@ -11722,7 +11018,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_50BETA, "BETA(ndarray real0, ndarray real1, int timeperiod=-0x80000000)\nBETA(real0, real1[, timeperiod=?])\n\nBeta (Statistic Functions)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nParameters:\n timeperiod: 5\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_50BETA, "BETA(ndarray real0, ndarray real1, int timeperiod=-0x80000000)\n\nBETA(real0, real1[, timeperiod=?])\n\nBeta (Statistic Functions)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nParameters:\n timeperiod: 5\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_51BETA = {"BETA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_51BETA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_50BETA}; static PyObject *__pyx_pw_5talib_7_ta_lib_51BETA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -11756,7 +11052,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 668, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 668, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -11775,7 +11071,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "BETA", 0) < 0) __PYX_ERR(4, 668, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "BETA", 0) < (0)) __PYX_ERR(4, 668, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("BETA", 0, 2, 3, i); __PYX_ERR(4, 668, __pyx_L3_error) } } @@ -11867,7 +11163,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_50BETA(CYTHON_UNUSED PyObject *__pyx_s __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 692, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 692, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 693, __pyx_L1_error) @@ -11917,7 +11213,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_52BOP, "BOP(ndarray open, ndarray high, ndarray low, ndarray close)\nBOP(open, high, low, close)\n\nBalance Of Power (Momentum Indicators)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_52BOP, "BOP(ndarray open, ndarray high, ndarray low, ndarray close)\n\nBOP(open, high, low, close)\n\nBalance Of Power (Momentum Indicators)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_53BOP = {"BOP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_53BOP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_52BOP}; static PyObject *__pyx_pw_5talib_7_ta_lib_53BOP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -11952,7 +11248,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 701, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 701, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -11975,7 +11271,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "BOP", 0) < 0) __PYX_ERR(4, 701, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "BOP", 0) < (0)) __PYX_ERR(4, 701, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("BOP", 1, 4, 4, i); __PYX_ERR(4, 701, __pyx_L3_error) } } @@ -12075,7 +11371,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_52BOP(CYTHON_UNUSED PyObject *__pyx_se __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 724, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 724, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 725, __pyx_L1_error) @@ -12127,7 +11423,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_54CCI, "CCI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\nCCI(high, low, close[, timeperiod=?])\n\nCommodity Channel Index (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_54CCI, "CCI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nCCI(high, low, close[, timeperiod=?])\n\nCommodity Channel Index (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_55CCI = {"CCI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_55CCI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_54CCI}; static PyObject *__pyx_pw_5talib_7_ta_lib_55CCI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -12162,7 +11458,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 733, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 733, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -12185,7 +11481,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CCI", 0) < 0) __PYX_ERR(4, 733, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CCI", 0) < (0)) __PYX_ERR(4, 733, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CCI", 0, 3, 4, i); __PYX_ERR(4, 733, __pyx_L3_error) } } @@ -12287,7 +11583,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_54CCI(CYTHON_UNUSED PyObject *__pyx_se __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 757, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 757, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 758, __pyx_L1_error) @@ -12338,7 +11634,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_56CDL2CROWS, "CDL2CROWS(ndarray open, ndarray high, ndarray low, ndarray close)\nCDL2CROWS(open, high, low, close)\n\nTwo Crows (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_56CDL2CROWS, "CDL2CROWS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL2CROWS(open, high, low, close)\n\nTwo Crows (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_57CDL2CROWS = {"CDL2CROWS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_57CDL2CROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_56CDL2CROWS}; static PyObject *__pyx_pw_5talib_7_ta_lib_57CDL2CROWS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -12373,7 +11669,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 766, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 766, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -12396,7 +11692,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDL2CROWS", 0) < 0) __PYX_ERR(4, 766, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDL2CROWS", 0) < (0)) __PYX_ERR(4, 766, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDL2CROWS", 1, 4, 4, i); __PYX_ERR(4, 766, __pyx_L3_error) } } @@ -12496,7 +11792,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_56CDL2CROWS(CYTHON_UNUSED PyObject *__ __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 789, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 789, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 790, __pyx_L1_error) @@ -12548,7 +11844,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_58CDL3BLACKCROWS, "CDL3BLACKCROWS(ndarray open, ndarray high, ndarray low, ndarray close)\nCDL3BLACKCROWS(open, high, low, close)\n\nThree Black Crows (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_58CDL3BLACKCROWS, "CDL3BLACKCROWS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3BLACKCROWS(open, high, low, close)\n\nThree Black Crows (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_59CDL3BLACKCROWS = {"CDL3BLACKCROWS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_59CDL3BLACKCROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_58CDL3BLACKCROWS}; static PyObject *__pyx_pw_5talib_7_ta_lib_59CDL3BLACKCROWS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -12583,7 +11879,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 798, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 798, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -12606,7 +11902,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDL3BLACKCROWS", 0) < 0) __PYX_ERR(4, 798, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDL3BLACKCROWS", 0) < (0)) __PYX_ERR(4, 798, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDL3BLACKCROWS", 1, 4, 4, i); __PYX_ERR(4, 798, __pyx_L3_error) } } @@ -12706,7 +12002,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_58CDL3BLACKCROWS(CYTHON_UNUSED PyObjec __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 821, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 821, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 822, __pyx_L1_error) @@ -12758,7 +12054,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_60CDL3INSIDE, "CDL3INSIDE(ndarray open, ndarray high, ndarray low, ndarray close)\nCDL3INSIDE(open, high, low, close)\n\nThree Inside Up/Down (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_60CDL3INSIDE, "CDL3INSIDE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3INSIDE(open, high, low, close)\n\nThree Inside Up/Down (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_61CDL3INSIDE = {"CDL3INSIDE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_61CDL3INSIDE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_60CDL3INSIDE}; static PyObject *__pyx_pw_5talib_7_ta_lib_61CDL3INSIDE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -12793,7 +12089,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 830, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 830, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -12816,7 +12112,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDL3INSIDE", 0) < 0) __PYX_ERR(4, 830, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDL3INSIDE", 0) < (0)) __PYX_ERR(4, 830, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDL3INSIDE", 1, 4, 4, i); __PYX_ERR(4, 830, __pyx_L3_error) } } @@ -12916,7 +12212,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_60CDL3INSIDE(CYTHON_UNUSED PyObject *_ __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 853, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 853, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 854, __pyx_L1_error) @@ -12968,7 +12264,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_62CDL3LINESTRIKE, "CDL3LINESTRIKE(ndarray open, ndarray high, ndarray low, ndarray close)\nCDL3LINESTRIKE(open, high, low, close)\n\nThree-Line Strike (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_62CDL3LINESTRIKE, "CDL3LINESTRIKE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3LINESTRIKE(open, high, low, close)\n\nThree-Line Strike (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_63CDL3LINESTRIKE = {"CDL3LINESTRIKE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_63CDL3LINESTRIKE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_62CDL3LINESTRIKE}; static PyObject *__pyx_pw_5talib_7_ta_lib_63CDL3LINESTRIKE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -13003,7 +12299,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 862, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 862, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -13026,7 +12322,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDL3LINESTRIKE", 0) < 0) __PYX_ERR(4, 862, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDL3LINESTRIKE", 0) < (0)) __PYX_ERR(4, 862, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDL3LINESTRIKE", 1, 4, 4, i); __PYX_ERR(4, 862, __pyx_L3_error) } } @@ -13126,7 +12422,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_62CDL3LINESTRIKE(CYTHON_UNUSED PyObjec __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 885, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 885, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 886, __pyx_L1_error) @@ -13178,7 +12474,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_64CDL3OUTSIDE, "CDL3OUTSIDE(ndarray open, ndarray high, ndarray low, ndarray close)\nCDL3OUTSIDE(open, high, low, close)\n\nThree Outside Up/Down (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_64CDL3OUTSIDE, "CDL3OUTSIDE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3OUTSIDE(open, high, low, close)\n\nThree Outside Up/Down (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_65CDL3OUTSIDE = {"CDL3OUTSIDE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_65CDL3OUTSIDE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_64CDL3OUTSIDE}; static PyObject *__pyx_pw_5talib_7_ta_lib_65CDL3OUTSIDE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -13213,7 +12509,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 894, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 894, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -13236,7 +12532,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDL3OUTSIDE", 0) < 0) __PYX_ERR(4, 894, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDL3OUTSIDE", 0) < (0)) __PYX_ERR(4, 894, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDL3OUTSIDE", 1, 4, 4, i); __PYX_ERR(4, 894, __pyx_L3_error) } } @@ -13336,7 +12632,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_64CDL3OUTSIDE(CYTHON_UNUSED PyObject * __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 917, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 917, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 918, __pyx_L1_error) @@ -13388,7 +12684,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_66CDL3STARSINSOUTH, "CDL3STARSINSOUTH(ndarray open, ndarray high, ndarray low, ndarray close)\nCDL3STARSINSOUTH(open, high, low, close)\n\nThree Stars In The South (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_66CDL3STARSINSOUTH, "CDL3STARSINSOUTH(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3STARSINSOUTH(open, high, low, close)\n\nThree Stars In The South (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_67CDL3STARSINSOUTH = {"CDL3STARSINSOUTH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_67CDL3STARSINSOUTH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_66CDL3STARSINSOUTH}; static PyObject *__pyx_pw_5talib_7_ta_lib_67CDL3STARSINSOUTH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -13423,7 +12719,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 926, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 926, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -13446,7 +12742,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDL3STARSINSOUTH", 0) < 0) __PYX_ERR(4, 926, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDL3STARSINSOUTH", 0) < (0)) __PYX_ERR(4, 926, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDL3STARSINSOUTH", 1, 4, 4, i); __PYX_ERR(4, 926, __pyx_L3_error) } } @@ -13546,7 +12842,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_66CDL3STARSINSOUTH(CYTHON_UNUSED PyObj __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 949, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 949, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 950, __pyx_L1_error) @@ -13598,7 +12894,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_68CDL3WHITESOLDIERS, "CDL3WHITESOLDIERS(ndarray open, ndarray high, ndarray low, ndarray close)\nCDL3WHITESOLDIERS(open, high, low, close)\n\nThree Advancing White Soldiers (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_68CDL3WHITESOLDIERS, "CDL3WHITESOLDIERS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3WHITESOLDIERS(open, high, low, close)\n\nThree Advancing White Soldiers (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_69CDL3WHITESOLDIERS = {"CDL3WHITESOLDIERS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_69CDL3WHITESOLDIERS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_68CDL3WHITESOLDIERS}; static PyObject *__pyx_pw_5talib_7_ta_lib_69CDL3WHITESOLDIERS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -13633,7 +12929,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 958, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 958, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -13656,7 +12952,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDL3WHITESOLDIERS", 0) < 0) __PYX_ERR(4, 958, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDL3WHITESOLDIERS", 0) < (0)) __PYX_ERR(4, 958, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDL3WHITESOLDIERS", 1, 4, 4, i); __PYX_ERR(4, 958, __pyx_L3_error) } } @@ -13756,7 +13052,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_68CDL3WHITESOLDIERS(CYTHON_UNUSED PyOb __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 981, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 981, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 982, __pyx_L1_error) @@ -13808,7 +13104,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_70CDLABANDONEDBABY, "CDLABANDONEDBABY(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\nCDLABANDONEDBABY(open, high, low, close[, penetration=?])\n\nAbandoned Baby (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.3\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_70CDLABANDONEDBABY, "CDLABANDONEDBABY(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\n\nCDLABANDONEDBABY(open, high, low, close[, penetration=?])\n\nAbandoned Baby (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.3\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_71CDLABANDONEDBABY = {"CDLABANDONEDBABY", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_71CDLABANDONEDBABY, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_70CDLABANDONEDBABY}; static PyObject *__pyx_pw_5talib_7_ta_lib_71CDLABANDONEDBABY(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -13844,7 +13140,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 990, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 990, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 5: @@ -13871,7 +13167,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLABANDONEDBABY", 0) < 0) __PYX_ERR(4, 990, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLABANDONEDBABY", 0) < (0)) __PYX_ERR(4, 990, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLABANDONEDBABY", 0, 4, 5, i); __PYX_ERR(4, 990, __pyx_L3_error) } } @@ -13983,7 +13279,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_70CDLABANDONEDBABY(CYTHON_UNUSED PyObj __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1015, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1015, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1016, __pyx_L1_error) @@ -14035,7 +13331,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_72CDLADVANCEBLOCK, "CDLADVANCEBLOCK(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLADVANCEBLOCK(open, high, low, close)\n\nAdvance Block (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_72CDLADVANCEBLOCK, "CDLADVANCEBLOCK(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLADVANCEBLOCK(open, high, low, close)\n\nAdvance Block (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_73CDLADVANCEBLOCK = {"CDLADVANCEBLOCK", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_73CDLADVANCEBLOCK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_72CDLADVANCEBLOCK}; static PyObject *__pyx_pw_5talib_7_ta_lib_73CDLADVANCEBLOCK(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -14070,7 +13366,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1024, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1024, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -14093,7 +13389,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLADVANCEBLOCK", 0) < 0) __PYX_ERR(4, 1024, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLADVANCEBLOCK", 0) < (0)) __PYX_ERR(4, 1024, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLADVANCEBLOCK", 1, 4, 4, i); __PYX_ERR(4, 1024, __pyx_L3_error) } } @@ -14193,7 +13489,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_72CDLADVANCEBLOCK(CYTHON_UNUSED PyObje __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1047, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1047, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1048, __pyx_L1_error) @@ -14245,7 +13541,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_74CDLBELTHOLD, "CDLBELTHOLD(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLBELTHOLD(open, high, low, close)\n\nBelt-hold (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_74CDLBELTHOLD, "CDLBELTHOLD(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLBELTHOLD(open, high, low, close)\n\nBelt-hold (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_75CDLBELTHOLD = {"CDLBELTHOLD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_75CDLBELTHOLD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_74CDLBELTHOLD}; static PyObject *__pyx_pw_5talib_7_ta_lib_75CDLBELTHOLD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -14280,7 +13576,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1056, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1056, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -14303,7 +13599,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLBELTHOLD", 0) < 0) __PYX_ERR(4, 1056, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLBELTHOLD", 0) < (0)) __PYX_ERR(4, 1056, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLBELTHOLD", 1, 4, 4, i); __PYX_ERR(4, 1056, __pyx_L3_error) } } @@ -14403,7 +13699,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_74CDLBELTHOLD(CYTHON_UNUSED PyObject * __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1079, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1079, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1080, __pyx_L1_error) @@ -14455,7 +13751,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_76CDLBREAKAWAY, "CDLBREAKAWAY(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLBREAKAWAY(open, high, low, close)\n\nBreakaway (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_76CDLBREAKAWAY, "CDLBREAKAWAY(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLBREAKAWAY(open, high, low, close)\n\nBreakaway (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_77CDLBREAKAWAY = {"CDLBREAKAWAY", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_77CDLBREAKAWAY, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_76CDLBREAKAWAY}; static PyObject *__pyx_pw_5talib_7_ta_lib_77CDLBREAKAWAY(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -14490,7 +13786,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1088, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1088, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -14513,7 +13809,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLBREAKAWAY", 0) < 0) __PYX_ERR(4, 1088, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLBREAKAWAY", 0) < (0)) __PYX_ERR(4, 1088, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLBREAKAWAY", 1, 4, 4, i); __PYX_ERR(4, 1088, __pyx_L3_error) } } @@ -14613,7 +13909,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_76CDLBREAKAWAY(CYTHON_UNUSED PyObject __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1111, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1111, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1112, __pyx_L1_error) @@ -14665,7 +13961,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_78CDLCLOSINGMARUBOZU, "CDLCLOSINGMARUBOZU(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLCLOSINGMARUBOZU(open, high, low, close)\n\nClosing Marubozu (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_78CDLCLOSINGMARUBOZU, "CDLCLOSINGMARUBOZU(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLCLOSINGMARUBOZU(open, high, low, close)\n\nClosing Marubozu (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_79CDLCLOSINGMARUBOZU = {"CDLCLOSINGMARUBOZU", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_79CDLCLOSINGMARUBOZU, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_78CDLCLOSINGMARUBOZU}; static PyObject *__pyx_pw_5talib_7_ta_lib_79CDLCLOSINGMARUBOZU(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -14700,7 +13996,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1120, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1120, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -14723,7 +14019,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLCLOSINGMARUBOZU", 0) < 0) __PYX_ERR(4, 1120, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLCLOSINGMARUBOZU", 0) < (0)) __PYX_ERR(4, 1120, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLCLOSINGMARUBOZU", 1, 4, 4, i); __PYX_ERR(4, 1120, __pyx_L3_error) } } @@ -14823,7 +14119,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_78CDLCLOSINGMARUBOZU(CYTHON_UNUSED PyO __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1143, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1143, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1144, __pyx_L1_error) @@ -14875,7 +14171,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_80CDLCONCEALBABYSWALL, "CDLCONCEALBABYSWALL(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLCONCEALBABYSWALL(open, high, low, close)\n\nConcealing Baby Swallow (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_80CDLCONCEALBABYSWALL, "CDLCONCEALBABYSWALL(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLCONCEALBABYSWALL(open, high, low, close)\n\nConcealing Baby Swallow (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_81CDLCONCEALBABYSWALL = {"CDLCONCEALBABYSWALL", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_81CDLCONCEALBABYSWALL, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_80CDLCONCEALBABYSWALL}; static PyObject *__pyx_pw_5talib_7_ta_lib_81CDLCONCEALBABYSWALL(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -14910,7 +14206,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1152, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1152, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -14933,7 +14229,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLCONCEALBABYSWALL", 0) < 0) __PYX_ERR(4, 1152, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLCONCEALBABYSWALL", 0) < (0)) __PYX_ERR(4, 1152, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLCONCEALBABYSWALL", 1, 4, 4, i); __PYX_ERR(4, 1152, __pyx_L3_error) } } @@ -15033,7 +14329,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_80CDLCONCEALBABYSWALL(CYTHON_UNUSED Py __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1175, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1175, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1176, __pyx_L1_error) @@ -15085,7 +14381,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_82CDLCOUNTERATTACK, "CDLCOUNTERATTACK(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLCOUNTERATTACK(open, high, low, close)\n\nCounterattack (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_82CDLCOUNTERATTACK, "CDLCOUNTERATTACK(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLCOUNTERATTACK(open, high, low, close)\n\nCounterattack (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_83CDLCOUNTERATTACK = {"CDLCOUNTERATTACK", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_83CDLCOUNTERATTACK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_82CDLCOUNTERATTACK}; static PyObject *__pyx_pw_5talib_7_ta_lib_83CDLCOUNTERATTACK(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -15120,7 +14416,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1184, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1184, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -15143,7 +14439,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLCOUNTERATTACK", 0) < 0) __PYX_ERR(4, 1184, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLCOUNTERATTACK", 0) < (0)) __PYX_ERR(4, 1184, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLCOUNTERATTACK", 1, 4, 4, i); __PYX_ERR(4, 1184, __pyx_L3_error) } } @@ -15243,7 +14539,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_82CDLCOUNTERATTACK(CYTHON_UNUSED PyObj __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1207, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1207, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1208, __pyx_L1_error) @@ -15295,7 +14591,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_84CDLDARKCLOUDCOVER, "CDLDARKCLOUDCOVER(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.5)\nCDLDARKCLOUDCOVER(open, high, low, close[, penetration=?])\n\nDark Cloud Cover (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.5\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_84CDLDARKCLOUDCOVER, "CDLDARKCLOUDCOVER(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.5)\n\nCDLDARKCLOUDCOVER(open, high, low, close[, penetration=?])\n\nDark Cloud Cover (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.5\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_85CDLDARKCLOUDCOVER = {"CDLDARKCLOUDCOVER", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_85CDLDARKCLOUDCOVER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_84CDLDARKCLOUDCOVER}; static PyObject *__pyx_pw_5talib_7_ta_lib_85CDLDARKCLOUDCOVER(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -15331,7 +14627,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1216, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1216, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 5: @@ -15358,7 +14654,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLDARKCLOUDCOVER", 0) < 0) __PYX_ERR(4, 1216, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLDARKCLOUDCOVER", 0) < (0)) __PYX_ERR(4, 1216, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLDARKCLOUDCOVER", 0, 4, 5, i); __PYX_ERR(4, 1216, __pyx_L3_error) } } @@ -15470,7 +14766,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_84CDLDARKCLOUDCOVER(CYTHON_UNUSED PyOb __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1241, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1241, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1242, __pyx_L1_error) @@ -15522,7 +14818,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_86CDLDOJI, "CDLDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLDOJI(open, high, low, close)\n\nDoji (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_86CDLDOJI, "CDLDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLDOJI(open, high, low, close)\n\nDoji (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_87CDLDOJI = {"CDLDOJI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_87CDLDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_86CDLDOJI}; static PyObject *__pyx_pw_5talib_7_ta_lib_87CDLDOJI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -15557,7 +14853,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1250, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1250, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -15580,7 +14876,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLDOJI", 0) < 0) __PYX_ERR(4, 1250, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLDOJI", 0) < (0)) __PYX_ERR(4, 1250, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLDOJI", 1, 4, 4, i); __PYX_ERR(4, 1250, __pyx_L3_error) } } @@ -15680,7 +14976,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_86CDLDOJI(CYTHON_UNUSED PyObject *__py __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1273, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1273, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1274, __pyx_L1_error) @@ -15732,7 +15028,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_88CDLDOJISTAR, "CDLDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLDOJISTAR(open, high, low, close)\n\nDoji Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_88CDLDOJISTAR, "CDLDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLDOJISTAR(open, high, low, close)\n\nDoji Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_89CDLDOJISTAR = {"CDLDOJISTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_89CDLDOJISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_88CDLDOJISTAR}; static PyObject *__pyx_pw_5talib_7_ta_lib_89CDLDOJISTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -15767,7 +15063,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1282, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1282, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -15790,7 +15086,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLDOJISTAR", 0) < 0) __PYX_ERR(4, 1282, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLDOJISTAR", 0) < (0)) __PYX_ERR(4, 1282, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLDOJISTAR", 1, 4, 4, i); __PYX_ERR(4, 1282, __pyx_L3_error) } } @@ -15890,7 +15186,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_88CDLDOJISTAR(CYTHON_UNUSED PyObject * __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1305, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1305, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1306, __pyx_L1_error) @@ -15942,7 +15238,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_90CDLDRAGONFLYDOJI, "CDLDRAGONFLYDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLDRAGONFLYDOJI(open, high, low, close)\n\nDragonfly Doji (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_90CDLDRAGONFLYDOJI, "CDLDRAGONFLYDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLDRAGONFLYDOJI(open, high, low, close)\n\nDragonfly Doji (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_91CDLDRAGONFLYDOJI = {"CDLDRAGONFLYDOJI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_91CDLDRAGONFLYDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_90CDLDRAGONFLYDOJI}; static PyObject *__pyx_pw_5talib_7_ta_lib_91CDLDRAGONFLYDOJI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -15977,7 +15273,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1314, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1314, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -16000,7 +15296,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLDRAGONFLYDOJI", 0) < 0) __PYX_ERR(4, 1314, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLDRAGONFLYDOJI", 0) < (0)) __PYX_ERR(4, 1314, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLDRAGONFLYDOJI", 1, 4, 4, i); __PYX_ERR(4, 1314, __pyx_L3_error) } } @@ -16100,7 +15396,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_90CDLDRAGONFLYDOJI(CYTHON_UNUSED PyObj __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1337, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1337, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1338, __pyx_L1_error) @@ -16152,7 +15448,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_92CDLENGULFING, "CDLENGULFING(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLENGULFING(open, high, low, close)\n\nEngulfing Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_92CDLENGULFING, "CDLENGULFING(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLENGULFING(open, high, low, close)\n\nEngulfing Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_93CDLENGULFING = {"CDLENGULFING", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_93CDLENGULFING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_92CDLENGULFING}; static PyObject *__pyx_pw_5talib_7_ta_lib_93CDLENGULFING(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -16187,7 +15483,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1346, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1346, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -16210,7 +15506,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLENGULFING", 0) < 0) __PYX_ERR(4, 1346, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLENGULFING", 0) < (0)) __PYX_ERR(4, 1346, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLENGULFING", 1, 4, 4, i); __PYX_ERR(4, 1346, __pyx_L3_error) } } @@ -16310,7 +15606,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_92CDLENGULFING(CYTHON_UNUSED PyObject __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1369, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1369, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1370, __pyx_L1_error) @@ -16362,7 +15658,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_94CDLEVENINGDOJISTAR, "CDLEVENINGDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\nCDLEVENINGDOJISTAR(open, high, low, close[, penetration=?])\n\nEvening Doji Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.3\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_94CDLEVENINGDOJISTAR, "CDLEVENINGDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\n\nCDLEVENINGDOJISTAR(open, high, low, close[, penetration=?])\n\nEvening Doji Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.3\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_95CDLEVENINGDOJISTAR = {"CDLEVENINGDOJISTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_95CDLEVENINGDOJISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_94CDLEVENINGDOJISTAR}; static PyObject *__pyx_pw_5talib_7_ta_lib_95CDLEVENINGDOJISTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -16398,7 +15694,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1378, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1378, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 5: @@ -16425,7 +15721,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLEVENINGDOJISTAR", 0) < 0) __PYX_ERR(4, 1378, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLEVENINGDOJISTAR", 0) < (0)) __PYX_ERR(4, 1378, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLEVENINGDOJISTAR", 0, 4, 5, i); __PYX_ERR(4, 1378, __pyx_L3_error) } } @@ -16537,7 +15833,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_94CDLEVENINGDOJISTAR(CYTHON_UNUSED PyO __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1403, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1403, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1404, __pyx_L1_error) @@ -16589,7 +15885,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_96CDLEVENINGSTAR, "CDLEVENINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\nCDLEVENINGSTAR(open, high, low, close[, penetration=?])\n\nEvening Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.3\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_96CDLEVENINGSTAR, "CDLEVENINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\n\nCDLEVENINGSTAR(open, high, low, close[, penetration=?])\n\nEvening Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.3\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_97CDLEVENINGSTAR = {"CDLEVENINGSTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_97CDLEVENINGSTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_96CDLEVENINGSTAR}; static PyObject *__pyx_pw_5talib_7_ta_lib_97CDLEVENINGSTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -16625,7 +15921,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1412, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1412, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 5: @@ -16652,7 +15948,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLEVENINGSTAR", 0) < 0) __PYX_ERR(4, 1412, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLEVENINGSTAR", 0) < (0)) __PYX_ERR(4, 1412, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLEVENINGSTAR", 0, 4, 5, i); __PYX_ERR(4, 1412, __pyx_L3_error) } } @@ -16764,7 +16060,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_96CDLEVENINGSTAR(CYTHON_UNUSED PyObjec __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1437, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1437, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1438, __pyx_L1_error) @@ -16816,7 +16112,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_98CDLGAPSIDESIDEWHITE, "CDLGAPSIDESIDEWHITE(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLGAPSIDESIDEWHITE(open, high, low, close)\n\nUp/Down-gap side-by-side white lines (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_98CDLGAPSIDESIDEWHITE, "CDLGAPSIDESIDEWHITE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLGAPSIDESIDEWHITE(open, high, low, close)\n\nUp/Down-gap side-by-side white lines (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_99CDLGAPSIDESIDEWHITE = {"CDLGAPSIDESIDEWHITE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_99CDLGAPSIDESIDEWHITE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_98CDLGAPSIDESIDEWHITE}; static PyObject *__pyx_pw_5talib_7_ta_lib_99CDLGAPSIDESIDEWHITE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -16851,7 +16147,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1446, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1446, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -16874,7 +16170,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLGAPSIDESIDEWHITE", 0) < 0) __PYX_ERR(4, 1446, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLGAPSIDESIDEWHITE", 0) < (0)) __PYX_ERR(4, 1446, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLGAPSIDESIDEWHITE", 1, 4, 4, i); __PYX_ERR(4, 1446, __pyx_L3_error) } } @@ -16974,7 +16270,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_98CDLGAPSIDESIDEWHITE(CYTHON_UNUSED Py __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1469, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1469, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1470, __pyx_L1_error) @@ -17026,7 +16322,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_100CDLGRAVESTONEDOJI, "CDLGRAVESTONEDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLGRAVESTONEDOJI(open, high, low, close)\n\nGravestone Doji (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_100CDLGRAVESTONEDOJI, "CDLGRAVESTONEDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLGRAVESTONEDOJI(open, high, low, close)\n\nGravestone Doji (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_101CDLGRAVESTONEDOJI = {"CDLGRAVESTONEDOJI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_101CDLGRAVESTONEDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_100CDLGRAVESTONEDOJI}; static PyObject *__pyx_pw_5talib_7_ta_lib_101CDLGRAVESTONEDOJI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -17061,7 +16357,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1478, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1478, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -17084,7 +16380,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLGRAVESTONEDOJI", 0) < 0) __PYX_ERR(4, 1478, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLGRAVESTONEDOJI", 0) < (0)) __PYX_ERR(4, 1478, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLGRAVESTONEDOJI", 1, 4, 4, i); __PYX_ERR(4, 1478, __pyx_L3_error) } } @@ -17184,7 +16480,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_100CDLGRAVESTONEDOJI(CYTHON_UNUSED PyO __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1501, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1501, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1502, __pyx_L1_error) @@ -17236,7 +16532,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_102CDLHAMMER, "CDLHAMMER(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLHAMMER(open, high, low, close)\n\nHammer (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_102CDLHAMMER, "CDLHAMMER(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHAMMER(open, high, low, close)\n\nHammer (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_103CDLHAMMER = {"CDLHAMMER", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_103CDLHAMMER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_102CDLHAMMER}; static PyObject *__pyx_pw_5talib_7_ta_lib_103CDLHAMMER(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -17271,7 +16567,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1510, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1510, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -17294,7 +16590,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHAMMER", 0) < 0) __PYX_ERR(4, 1510, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHAMMER", 0) < (0)) __PYX_ERR(4, 1510, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLHAMMER", 1, 4, 4, i); __PYX_ERR(4, 1510, __pyx_L3_error) } } @@ -17394,7 +16690,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_102CDLHAMMER(CYTHON_UNUSED PyObject *_ __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1533, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1533, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1534, __pyx_L1_error) @@ -17446,7 +16742,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_104CDLHANGINGMAN, "CDLHANGINGMAN(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLHANGINGMAN(open, high, low, close)\n\nHanging Man (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_104CDLHANGINGMAN, "CDLHANGINGMAN(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHANGINGMAN(open, high, low, close)\n\nHanging Man (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_105CDLHANGINGMAN = {"CDLHANGINGMAN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_105CDLHANGINGMAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_104CDLHANGINGMAN}; static PyObject *__pyx_pw_5talib_7_ta_lib_105CDLHANGINGMAN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -17481,7 +16777,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1542, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1542, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -17504,7 +16800,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHANGINGMAN", 0) < 0) __PYX_ERR(4, 1542, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHANGINGMAN", 0) < (0)) __PYX_ERR(4, 1542, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLHANGINGMAN", 1, 4, 4, i); __PYX_ERR(4, 1542, __pyx_L3_error) } } @@ -17604,7 +16900,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_104CDLHANGINGMAN(CYTHON_UNUSED PyObjec __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1565, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1565, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1566, __pyx_L1_error) @@ -17656,7 +16952,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_106CDLHARAMI, "CDLHARAMI(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLHARAMI(open, high, low, close)\n\nHarami Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_106CDLHARAMI, "CDLHARAMI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHARAMI(open, high, low, close)\n\nHarami Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_107CDLHARAMI = {"CDLHARAMI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_107CDLHARAMI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_106CDLHARAMI}; static PyObject *__pyx_pw_5talib_7_ta_lib_107CDLHARAMI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -17691,7 +16987,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1574, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1574, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -17714,7 +17010,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHARAMI", 0) < 0) __PYX_ERR(4, 1574, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHARAMI", 0) < (0)) __PYX_ERR(4, 1574, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLHARAMI", 1, 4, 4, i); __PYX_ERR(4, 1574, __pyx_L3_error) } } @@ -17814,7 +17110,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_106CDLHARAMI(CYTHON_UNUSED PyObject *_ __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1597, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1597, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1598, __pyx_L1_error) @@ -17866,7 +17162,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_108CDLHARAMICROSS, "CDLHARAMICROSS(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLHARAMICROSS(open, high, low, close)\n\nHarami Cross Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_108CDLHARAMICROSS, "CDLHARAMICROSS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHARAMICROSS(open, high, low, close)\n\nHarami Cross Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_109CDLHARAMICROSS = {"CDLHARAMICROSS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_109CDLHARAMICROSS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_108CDLHARAMICROSS}; static PyObject *__pyx_pw_5talib_7_ta_lib_109CDLHARAMICROSS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -17901,7 +17197,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1606, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1606, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -17924,7 +17220,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHARAMICROSS", 0) < 0) __PYX_ERR(4, 1606, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHARAMICROSS", 0) < (0)) __PYX_ERR(4, 1606, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLHARAMICROSS", 1, 4, 4, i); __PYX_ERR(4, 1606, __pyx_L3_error) } } @@ -18024,7 +17320,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_108CDLHARAMICROSS(CYTHON_UNUSED PyObje __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1629, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1629, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1630, __pyx_L1_error) @@ -18076,7 +17372,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_110CDLHIGHWAVE, "CDLHIGHWAVE(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLHIGHWAVE(open, high, low, close)\n\nHigh-Wave Candle (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_110CDLHIGHWAVE, "CDLHIGHWAVE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHIGHWAVE(open, high, low, close)\n\nHigh-Wave Candle (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_111CDLHIGHWAVE = {"CDLHIGHWAVE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_111CDLHIGHWAVE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_110CDLHIGHWAVE}; static PyObject *__pyx_pw_5talib_7_ta_lib_111CDLHIGHWAVE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -18111,7 +17407,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1638, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1638, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -18134,7 +17430,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHIGHWAVE", 0) < 0) __PYX_ERR(4, 1638, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHIGHWAVE", 0) < (0)) __PYX_ERR(4, 1638, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLHIGHWAVE", 1, 4, 4, i); __PYX_ERR(4, 1638, __pyx_L3_error) } } @@ -18234,7 +17530,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_110CDLHIGHWAVE(CYTHON_UNUSED PyObject __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1661, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1661, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1662, __pyx_L1_error) @@ -18286,7 +17582,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_112CDLHIKKAKE, "CDLHIKKAKE(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLHIKKAKE(open, high, low, close)\n\nHikkake Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_112CDLHIKKAKE, "CDLHIKKAKE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHIKKAKE(open, high, low, close)\n\nHikkake Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_113CDLHIKKAKE = {"CDLHIKKAKE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_113CDLHIKKAKE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_112CDLHIKKAKE}; static PyObject *__pyx_pw_5talib_7_ta_lib_113CDLHIKKAKE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -18321,7 +17617,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1670, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1670, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -18344,7 +17640,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHIKKAKE", 0) < 0) __PYX_ERR(4, 1670, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHIKKAKE", 0) < (0)) __PYX_ERR(4, 1670, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLHIKKAKE", 1, 4, 4, i); __PYX_ERR(4, 1670, __pyx_L3_error) } } @@ -18444,7 +17740,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_112CDLHIKKAKE(CYTHON_UNUSED PyObject * __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1693, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1693, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1694, __pyx_L1_error) @@ -18496,7 +17792,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_114CDLHIKKAKEMOD, "CDLHIKKAKEMOD(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLHIKKAKEMOD(open, high, low, close)\n\nModified Hikkake Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_114CDLHIKKAKEMOD, "CDLHIKKAKEMOD(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHIKKAKEMOD(open, high, low, close)\n\nModified Hikkake Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_115CDLHIKKAKEMOD = {"CDLHIKKAKEMOD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_115CDLHIKKAKEMOD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_114CDLHIKKAKEMOD}; static PyObject *__pyx_pw_5talib_7_ta_lib_115CDLHIKKAKEMOD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -18531,7 +17827,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1702, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1702, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -18554,7 +17850,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHIKKAKEMOD", 0) < 0) __PYX_ERR(4, 1702, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHIKKAKEMOD", 0) < (0)) __PYX_ERR(4, 1702, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLHIKKAKEMOD", 1, 4, 4, i); __PYX_ERR(4, 1702, __pyx_L3_error) } } @@ -18654,7 +17950,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_114CDLHIKKAKEMOD(CYTHON_UNUSED PyObjec __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1725, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1725, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1726, __pyx_L1_error) @@ -18706,7 +18002,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_116CDLHOMINGPIGEON, "CDLHOMINGPIGEON(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLHOMINGPIGEON(open, high, low, close)\n\nHoming Pigeon (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_116CDLHOMINGPIGEON, "CDLHOMINGPIGEON(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHOMINGPIGEON(open, high, low, close)\n\nHoming Pigeon (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_117CDLHOMINGPIGEON = {"CDLHOMINGPIGEON", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_117CDLHOMINGPIGEON, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_116CDLHOMINGPIGEON}; static PyObject *__pyx_pw_5talib_7_ta_lib_117CDLHOMINGPIGEON(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -18741,7 +18037,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1734, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1734, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -18764,7 +18060,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHOMINGPIGEON", 0) < 0) __PYX_ERR(4, 1734, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHOMINGPIGEON", 0) < (0)) __PYX_ERR(4, 1734, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLHOMINGPIGEON", 1, 4, 4, i); __PYX_ERR(4, 1734, __pyx_L3_error) } } @@ -18864,7 +18160,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_116CDLHOMINGPIGEON(CYTHON_UNUSED PyObj __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1757, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1757, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1758, __pyx_L1_error) @@ -18916,7 +18212,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_118CDLIDENTICAL3CROWS, "CDLIDENTICAL3CROWS(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLIDENTICAL3CROWS(open, high, low, close)\n\nIdentical Three Crows (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_118CDLIDENTICAL3CROWS, "CDLIDENTICAL3CROWS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLIDENTICAL3CROWS(open, high, low, close)\n\nIdentical Three Crows (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_119CDLIDENTICAL3CROWS = {"CDLIDENTICAL3CROWS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_119CDLIDENTICAL3CROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_118CDLIDENTICAL3CROWS}; static PyObject *__pyx_pw_5talib_7_ta_lib_119CDLIDENTICAL3CROWS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -18951,7 +18247,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1766, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1766, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -18974,7 +18270,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLIDENTICAL3CROWS", 0) < 0) __PYX_ERR(4, 1766, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLIDENTICAL3CROWS", 0) < (0)) __PYX_ERR(4, 1766, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLIDENTICAL3CROWS", 1, 4, 4, i); __PYX_ERR(4, 1766, __pyx_L3_error) } } @@ -19074,7 +18370,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_118CDLIDENTICAL3CROWS(CYTHON_UNUSED Py __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1789, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1789, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1790, __pyx_L1_error) @@ -19126,7 +18422,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_120CDLINNECK, "CDLINNECK(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLINNECK(open, high, low, close)\n\nIn-Neck Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_120CDLINNECK, "CDLINNECK(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLINNECK(open, high, low, close)\n\nIn-Neck Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_121CDLINNECK = {"CDLINNECK", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_121CDLINNECK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_120CDLINNECK}; static PyObject *__pyx_pw_5talib_7_ta_lib_121CDLINNECK(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -19161,7 +18457,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1798, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1798, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -19184,7 +18480,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLINNECK", 0) < 0) __PYX_ERR(4, 1798, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLINNECK", 0) < (0)) __PYX_ERR(4, 1798, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLINNECK", 1, 4, 4, i); __PYX_ERR(4, 1798, __pyx_L3_error) } } @@ -19284,7 +18580,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_120CDLINNECK(CYTHON_UNUSED PyObject *_ __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1821, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1821, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1822, __pyx_L1_error) @@ -19336,7 +18632,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_122CDLINVERTEDHAMMER, "CDLINVERTEDHAMMER(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLINVERTEDHAMMER(open, high, low, close)\n\nInverted Hammer (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_122CDLINVERTEDHAMMER, "CDLINVERTEDHAMMER(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLINVERTEDHAMMER(open, high, low, close)\n\nInverted Hammer (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_123CDLINVERTEDHAMMER = {"CDLINVERTEDHAMMER", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_123CDLINVERTEDHAMMER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_122CDLINVERTEDHAMMER}; static PyObject *__pyx_pw_5talib_7_ta_lib_123CDLINVERTEDHAMMER(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -19371,7 +18667,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1830, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1830, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -19394,7 +18690,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLINVERTEDHAMMER", 0) < 0) __PYX_ERR(4, 1830, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLINVERTEDHAMMER", 0) < (0)) __PYX_ERR(4, 1830, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLINVERTEDHAMMER", 1, 4, 4, i); __PYX_ERR(4, 1830, __pyx_L3_error) } } @@ -19494,7 +18790,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_122CDLINVERTEDHAMMER(CYTHON_UNUSED PyO __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1853, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1853, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1854, __pyx_L1_error) @@ -19546,7 +18842,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_124CDLKICKING, "CDLKICKING(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLKICKING(open, high, low, close)\n\nKicking (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_124CDLKICKING, "CDLKICKING(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLKICKING(open, high, low, close)\n\nKicking (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_125CDLKICKING = {"CDLKICKING", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_125CDLKICKING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_124CDLKICKING}; static PyObject *__pyx_pw_5talib_7_ta_lib_125CDLKICKING(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -19581,7 +18877,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1862, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1862, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -19604,7 +18900,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLKICKING", 0) < 0) __PYX_ERR(4, 1862, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLKICKING", 0) < (0)) __PYX_ERR(4, 1862, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLKICKING", 1, 4, 4, i); __PYX_ERR(4, 1862, __pyx_L3_error) } } @@ -19704,7 +19000,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_124CDLKICKING(CYTHON_UNUSED PyObject * __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1885, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1885, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1886, __pyx_L1_error) @@ -19756,7 +19052,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_126CDLKICKINGBYLENGTH, "CDLKICKINGBYLENGTH(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLKICKINGBYLENGTH(open, high, low, close)\n\nKicking - bull/bear determined by the longer marubozu (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_126CDLKICKINGBYLENGTH, "CDLKICKINGBYLENGTH(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLKICKINGBYLENGTH(open, high, low, close)\n\nKicking - bull/bear determined by the longer marubozu (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_127CDLKICKINGBYLENGTH = {"CDLKICKINGBYLENGTH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_127CDLKICKINGBYLENGTH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_126CDLKICKINGBYLENGTH}; static PyObject *__pyx_pw_5talib_7_ta_lib_127CDLKICKINGBYLENGTH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -19791,7 +19087,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1894, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1894, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -19814,7 +19110,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLKICKINGBYLENGTH", 0) < 0) __PYX_ERR(4, 1894, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLKICKINGBYLENGTH", 0) < (0)) __PYX_ERR(4, 1894, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLKICKINGBYLENGTH", 1, 4, 4, i); __PYX_ERR(4, 1894, __pyx_L3_error) } } @@ -19914,7 +19210,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_126CDLKICKINGBYLENGTH(CYTHON_UNUSED Py __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1917, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1917, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1918, __pyx_L1_error) @@ -19966,7 +19262,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_128CDLLADDERBOTTOM, "CDLLADDERBOTTOM(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLLADDERBOTTOM(open, high, low, close)\n\nLadder Bottom (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_128CDLLADDERBOTTOM, "CDLLADDERBOTTOM(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLLADDERBOTTOM(open, high, low, close)\n\nLadder Bottom (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_129CDLLADDERBOTTOM = {"CDLLADDERBOTTOM", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_129CDLLADDERBOTTOM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_128CDLLADDERBOTTOM}; static PyObject *__pyx_pw_5talib_7_ta_lib_129CDLLADDERBOTTOM(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -20001,7 +19297,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1926, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1926, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -20024,7 +19320,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLLADDERBOTTOM", 0) < 0) __PYX_ERR(4, 1926, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLLADDERBOTTOM", 0) < (0)) __PYX_ERR(4, 1926, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLLADDERBOTTOM", 1, 4, 4, i); __PYX_ERR(4, 1926, __pyx_L3_error) } } @@ -20124,7 +19420,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_128CDLLADDERBOTTOM(CYTHON_UNUSED PyObj __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1949, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1949, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1950, __pyx_L1_error) @@ -20176,7 +19472,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_130CDLLONGLEGGEDDOJI, "CDLLONGLEGGEDDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLLONGLEGGEDDOJI(open, high, low, close)\n\nLong Legged Doji (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_130CDLLONGLEGGEDDOJI, "CDLLONGLEGGEDDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLLONGLEGGEDDOJI(open, high, low, close)\n\nLong Legged Doji (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_131CDLLONGLEGGEDDOJI = {"CDLLONGLEGGEDDOJI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_131CDLLONGLEGGEDDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_130CDLLONGLEGGEDDOJI}; static PyObject *__pyx_pw_5talib_7_ta_lib_131CDLLONGLEGGEDDOJI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -20211,7 +19507,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1958, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1958, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -20234,7 +19530,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLLONGLEGGEDDOJI", 0) < 0) __PYX_ERR(4, 1958, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLLONGLEGGEDDOJI", 0) < (0)) __PYX_ERR(4, 1958, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLLONGLEGGEDDOJI", 1, 4, 4, i); __PYX_ERR(4, 1958, __pyx_L3_error) } } @@ -20334,7 +19630,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_130CDLLONGLEGGEDDOJI(CYTHON_UNUSED PyO __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1981, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 1981, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1982, __pyx_L1_error) @@ -20386,7 +19682,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_132CDLLONGLINE, "CDLLONGLINE(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLLONGLINE(open, high, low, close)\n\nLong Line Candle (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_132CDLLONGLINE, "CDLLONGLINE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLLONGLINE(open, high, low, close)\n\nLong Line Candle (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_133CDLLONGLINE = {"CDLLONGLINE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_133CDLLONGLINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_132CDLLONGLINE}; static PyObject *__pyx_pw_5talib_7_ta_lib_133CDLLONGLINE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -20421,7 +19717,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1990, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 1990, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -20444,7 +19740,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLLONGLINE", 0) < 0) __PYX_ERR(4, 1990, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLLONGLINE", 0) < (0)) __PYX_ERR(4, 1990, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLLONGLINE", 1, 4, 4, i); __PYX_ERR(4, 1990, __pyx_L3_error) } } @@ -20544,7 +19840,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_132CDLLONGLINE(CYTHON_UNUSED PyObject __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2013, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2013, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2014, __pyx_L1_error) @@ -20596,7 +19892,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_134CDLMARUBOZU, "CDLMARUBOZU(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLMARUBOZU(open, high, low, close)\n\nMarubozu (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_134CDLMARUBOZU, "CDLMARUBOZU(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLMARUBOZU(open, high, low, close)\n\nMarubozu (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_135CDLMARUBOZU = {"CDLMARUBOZU", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_135CDLMARUBOZU, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_134CDLMARUBOZU}; static PyObject *__pyx_pw_5talib_7_ta_lib_135CDLMARUBOZU(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -20631,7 +19927,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2022, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2022, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -20654,7 +19950,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLMARUBOZU", 0) < 0) __PYX_ERR(4, 2022, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLMARUBOZU", 0) < (0)) __PYX_ERR(4, 2022, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLMARUBOZU", 1, 4, 4, i); __PYX_ERR(4, 2022, __pyx_L3_error) } } @@ -20754,7 +20050,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_134CDLMARUBOZU(CYTHON_UNUSED PyObject __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2045, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2045, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2046, __pyx_L1_error) @@ -20806,7 +20102,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_136CDLMATCHINGLOW, "CDLMATCHINGLOW(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLMATCHINGLOW(open, high, low, close)\n\nMatching Low (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_136CDLMATCHINGLOW, "CDLMATCHINGLOW(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLMATCHINGLOW(open, high, low, close)\n\nMatching Low (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_137CDLMATCHINGLOW = {"CDLMATCHINGLOW", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_137CDLMATCHINGLOW, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_136CDLMATCHINGLOW}; static PyObject *__pyx_pw_5talib_7_ta_lib_137CDLMATCHINGLOW(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -20841,7 +20137,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2054, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2054, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -20864,7 +20160,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLMATCHINGLOW", 0) < 0) __PYX_ERR(4, 2054, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLMATCHINGLOW", 0) < (0)) __PYX_ERR(4, 2054, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLMATCHINGLOW", 1, 4, 4, i); __PYX_ERR(4, 2054, __pyx_L3_error) } } @@ -20964,7 +20260,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_136CDLMATCHINGLOW(CYTHON_UNUSED PyObje __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2077, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2077, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2078, __pyx_L1_error) @@ -21016,7 +20312,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_138CDLMATHOLD, "CDLMATHOLD(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.5)\nCDLMATHOLD(open, high, low, close[, penetration=?])\n\nMat Hold (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.5\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_138CDLMATHOLD, "CDLMATHOLD(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.5)\n\nCDLMATHOLD(open, high, low, close[, penetration=?])\n\nMat Hold (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.5\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_139CDLMATHOLD = {"CDLMATHOLD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_139CDLMATHOLD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_138CDLMATHOLD}; static PyObject *__pyx_pw_5talib_7_ta_lib_139CDLMATHOLD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -21052,7 +20348,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2086, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2086, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 5: @@ -21079,7 +20375,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLMATHOLD", 0) < 0) __PYX_ERR(4, 2086, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLMATHOLD", 0) < (0)) __PYX_ERR(4, 2086, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLMATHOLD", 0, 4, 5, i); __PYX_ERR(4, 2086, __pyx_L3_error) } } @@ -21191,7 +20487,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_138CDLMATHOLD(CYTHON_UNUSED PyObject * __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2111, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2111, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2112, __pyx_L1_error) @@ -21243,7 +20539,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_140CDLMORNINGDOJISTAR, "CDLMORNINGDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\nCDLMORNINGDOJISTAR(open, high, low, close[, penetration=?])\n\nMorning Doji Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.3\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_140CDLMORNINGDOJISTAR, "CDLMORNINGDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\n\nCDLMORNINGDOJISTAR(open, high, low, close[, penetration=?])\n\nMorning Doji Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.3\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_141CDLMORNINGDOJISTAR = {"CDLMORNINGDOJISTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_141CDLMORNINGDOJISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_140CDLMORNINGDOJISTAR}; static PyObject *__pyx_pw_5talib_7_ta_lib_141CDLMORNINGDOJISTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -21279,7 +20575,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2120, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2120, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 5: @@ -21306,7 +20602,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLMORNINGDOJISTAR", 0) < 0) __PYX_ERR(4, 2120, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLMORNINGDOJISTAR", 0) < (0)) __PYX_ERR(4, 2120, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLMORNINGDOJISTAR", 0, 4, 5, i); __PYX_ERR(4, 2120, __pyx_L3_error) } } @@ -21418,7 +20714,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_140CDLMORNINGDOJISTAR(CYTHON_UNUSED Py __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2145, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2145, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2146, __pyx_L1_error) @@ -21470,7 +20766,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_142CDLMORNINGSTAR, "CDLMORNINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\nCDLMORNINGSTAR(open, high, low, close[, penetration=?])\n\nMorning Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.3\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_142CDLMORNINGSTAR, "CDLMORNINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\n\nCDLMORNINGSTAR(open, high, low, close[, penetration=?])\n\nMorning Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.3\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_143CDLMORNINGSTAR = {"CDLMORNINGSTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_143CDLMORNINGSTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_142CDLMORNINGSTAR}; static PyObject *__pyx_pw_5talib_7_ta_lib_143CDLMORNINGSTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -21506,7 +20802,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2154, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2154, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 5: @@ -21533,7 +20829,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLMORNINGSTAR", 0) < 0) __PYX_ERR(4, 2154, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLMORNINGSTAR", 0) < (0)) __PYX_ERR(4, 2154, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLMORNINGSTAR", 0, 4, 5, i); __PYX_ERR(4, 2154, __pyx_L3_error) } } @@ -21645,7 +20941,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_142CDLMORNINGSTAR(CYTHON_UNUSED PyObje __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2179, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2179, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2180, __pyx_L1_error) @@ -21697,7 +20993,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_144CDLONNECK, "CDLONNECK(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLONNECK(open, high, low, close)\n\nOn-Neck Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_144CDLONNECK, "CDLONNECK(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLONNECK(open, high, low, close)\n\nOn-Neck Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_145CDLONNECK = {"CDLONNECK", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_145CDLONNECK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_144CDLONNECK}; static PyObject *__pyx_pw_5talib_7_ta_lib_145CDLONNECK(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -21732,7 +21028,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2188, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2188, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -21755,7 +21051,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLONNECK", 0) < 0) __PYX_ERR(4, 2188, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLONNECK", 0) < (0)) __PYX_ERR(4, 2188, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLONNECK", 1, 4, 4, i); __PYX_ERR(4, 2188, __pyx_L3_error) } } @@ -21855,7 +21151,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_144CDLONNECK(CYTHON_UNUSED PyObject *_ __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2211, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2211, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2212, __pyx_L1_error) @@ -21907,7 +21203,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_146CDLPIERCING, "CDLPIERCING(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLPIERCING(open, high, low, close)\n\nPiercing Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_146CDLPIERCING, "CDLPIERCING(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLPIERCING(open, high, low, close)\n\nPiercing Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_147CDLPIERCING = {"CDLPIERCING", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_147CDLPIERCING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_146CDLPIERCING}; static PyObject *__pyx_pw_5talib_7_ta_lib_147CDLPIERCING(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -21942,7 +21238,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2220, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2220, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -21965,7 +21261,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLPIERCING", 0) < 0) __PYX_ERR(4, 2220, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLPIERCING", 0) < (0)) __PYX_ERR(4, 2220, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLPIERCING", 1, 4, 4, i); __PYX_ERR(4, 2220, __pyx_L3_error) } } @@ -22065,7 +21361,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_146CDLPIERCING(CYTHON_UNUSED PyObject __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2243, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2243, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2244, __pyx_L1_error) @@ -22117,7 +21413,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_148CDLRICKSHAWMAN, "CDLRICKSHAWMAN(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLRICKSHAWMAN(open, high, low, close)\n\nRickshaw Man (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_148CDLRICKSHAWMAN, "CDLRICKSHAWMAN(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLRICKSHAWMAN(open, high, low, close)\n\nRickshaw Man (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_149CDLRICKSHAWMAN = {"CDLRICKSHAWMAN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_149CDLRICKSHAWMAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_148CDLRICKSHAWMAN}; static PyObject *__pyx_pw_5talib_7_ta_lib_149CDLRICKSHAWMAN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -22152,7 +21448,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2252, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2252, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -22175,7 +21471,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLRICKSHAWMAN", 0) < 0) __PYX_ERR(4, 2252, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLRICKSHAWMAN", 0) < (0)) __PYX_ERR(4, 2252, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLRICKSHAWMAN", 1, 4, 4, i); __PYX_ERR(4, 2252, __pyx_L3_error) } } @@ -22275,7 +21571,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_148CDLRICKSHAWMAN(CYTHON_UNUSED PyObje __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2275, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2275, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2276, __pyx_L1_error) @@ -22327,7 +21623,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_150CDLRISEFALL3METHODS, "CDLRISEFALL3METHODS(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLRISEFALL3METHODS(open, high, low, close)\n\nRising/Falling Three Methods (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_150CDLRISEFALL3METHODS, "CDLRISEFALL3METHODS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLRISEFALL3METHODS(open, high, low, close)\n\nRising/Falling Three Methods (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_151CDLRISEFALL3METHODS = {"CDLRISEFALL3METHODS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_151CDLRISEFALL3METHODS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_150CDLRISEFALL3METHODS}; static PyObject *__pyx_pw_5talib_7_ta_lib_151CDLRISEFALL3METHODS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -22362,7 +21658,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2284, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2284, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -22385,7 +21681,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLRISEFALL3METHODS", 0) < 0) __PYX_ERR(4, 2284, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLRISEFALL3METHODS", 0) < (0)) __PYX_ERR(4, 2284, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLRISEFALL3METHODS", 1, 4, 4, i); __PYX_ERR(4, 2284, __pyx_L3_error) } } @@ -22485,7 +21781,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_150CDLRISEFALL3METHODS(CYTHON_UNUSED P __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2307, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2307, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2308, __pyx_L1_error) @@ -22537,7 +21833,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_152CDLSEPARATINGLINES, "CDLSEPARATINGLINES(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLSEPARATINGLINES(open, high, low, close)\n\nSeparating Lines (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_152CDLSEPARATINGLINES, "CDLSEPARATINGLINES(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSEPARATINGLINES(open, high, low, close)\n\nSeparating Lines (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_153CDLSEPARATINGLINES = {"CDLSEPARATINGLINES", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_153CDLSEPARATINGLINES, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_152CDLSEPARATINGLINES}; static PyObject *__pyx_pw_5talib_7_ta_lib_153CDLSEPARATINGLINES(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -22572,7 +21868,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2316, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2316, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -22595,7 +21891,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLSEPARATINGLINES", 0) < 0) __PYX_ERR(4, 2316, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLSEPARATINGLINES", 0) < (0)) __PYX_ERR(4, 2316, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLSEPARATINGLINES", 1, 4, 4, i); __PYX_ERR(4, 2316, __pyx_L3_error) } } @@ -22695,7 +21991,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_152CDLSEPARATINGLINES(CYTHON_UNUSED Py __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2339, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2339, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2340, __pyx_L1_error) @@ -22747,7 +22043,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_154CDLSHOOTINGSTAR, "CDLSHOOTINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLSHOOTINGSTAR(open, high, low, close)\n\nShooting Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_154CDLSHOOTINGSTAR, "CDLSHOOTINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSHOOTINGSTAR(open, high, low, close)\n\nShooting Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_155CDLSHOOTINGSTAR = {"CDLSHOOTINGSTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_155CDLSHOOTINGSTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_154CDLSHOOTINGSTAR}; static PyObject *__pyx_pw_5talib_7_ta_lib_155CDLSHOOTINGSTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -22782,7 +22078,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2348, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2348, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -22805,7 +22101,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLSHOOTINGSTAR", 0) < 0) __PYX_ERR(4, 2348, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLSHOOTINGSTAR", 0) < (0)) __PYX_ERR(4, 2348, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLSHOOTINGSTAR", 1, 4, 4, i); __PYX_ERR(4, 2348, __pyx_L3_error) } } @@ -22905,7 +22201,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_154CDLSHOOTINGSTAR(CYTHON_UNUSED PyObj __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2371, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2371, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2372, __pyx_L1_error) @@ -22957,7 +22253,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_156CDLSHORTLINE, "CDLSHORTLINE(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLSHORTLINE(open, high, low, close)\n\nShort Line Candle (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_156CDLSHORTLINE, "CDLSHORTLINE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSHORTLINE(open, high, low, close)\n\nShort Line Candle (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_157CDLSHORTLINE = {"CDLSHORTLINE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_157CDLSHORTLINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_156CDLSHORTLINE}; static PyObject *__pyx_pw_5talib_7_ta_lib_157CDLSHORTLINE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -22992,7 +22288,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2380, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2380, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -23015,7 +22311,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLSHORTLINE", 0) < 0) __PYX_ERR(4, 2380, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLSHORTLINE", 0) < (0)) __PYX_ERR(4, 2380, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLSHORTLINE", 1, 4, 4, i); __PYX_ERR(4, 2380, __pyx_L3_error) } } @@ -23115,7 +22411,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_156CDLSHORTLINE(CYTHON_UNUSED PyObject __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2403, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2403, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2404, __pyx_L1_error) @@ -23167,7 +22463,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_158CDLSPINNINGTOP, "CDLSPINNINGTOP(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLSPINNINGTOP(open, high, low, close)\n\nSpinning Top (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_158CDLSPINNINGTOP, "CDLSPINNINGTOP(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSPINNINGTOP(open, high, low, close)\n\nSpinning Top (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_159CDLSPINNINGTOP = {"CDLSPINNINGTOP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_159CDLSPINNINGTOP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_158CDLSPINNINGTOP}; static PyObject *__pyx_pw_5talib_7_ta_lib_159CDLSPINNINGTOP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -23202,7 +22498,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2412, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2412, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -23225,7 +22521,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLSPINNINGTOP", 0) < 0) __PYX_ERR(4, 2412, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLSPINNINGTOP", 0) < (0)) __PYX_ERR(4, 2412, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLSPINNINGTOP", 1, 4, 4, i); __PYX_ERR(4, 2412, __pyx_L3_error) } } @@ -23325,7 +22621,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_158CDLSPINNINGTOP(CYTHON_UNUSED PyObje __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2435, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2435, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2436, __pyx_L1_error) @@ -23377,7 +22673,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_160CDLSTALLEDPATTERN, "CDLSTALLEDPATTERN(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLSTALLEDPATTERN(open, high, low, close)\n\nStalled Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_160CDLSTALLEDPATTERN, "CDLSTALLEDPATTERN(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSTALLEDPATTERN(open, high, low, close)\n\nStalled Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_161CDLSTALLEDPATTERN = {"CDLSTALLEDPATTERN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_161CDLSTALLEDPATTERN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_160CDLSTALLEDPATTERN}; static PyObject *__pyx_pw_5talib_7_ta_lib_161CDLSTALLEDPATTERN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -23412,7 +22708,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2444, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2444, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -23435,7 +22731,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLSTALLEDPATTERN", 0) < 0) __PYX_ERR(4, 2444, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLSTALLEDPATTERN", 0) < (0)) __PYX_ERR(4, 2444, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLSTALLEDPATTERN", 1, 4, 4, i); __PYX_ERR(4, 2444, __pyx_L3_error) } } @@ -23535,7 +22831,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_160CDLSTALLEDPATTERN(CYTHON_UNUSED PyO __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2467, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2467, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2468, __pyx_L1_error) @@ -23587,7 +22883,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_162CDLSTICKSANDWICH, "CDLSTICKSANDWICH(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLSTICKSANDWICH(open, high, low, close)\n\nStick Sandwich (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_162CDLSTICKSANDWICH, "CDLSTICKSANDWICH(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSTICKSANDWICH(open, high, low, close)\n\nStick Sandwich (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_163CDLSTICKSANDWICH = {"CDLSTICKSANDWICH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_163CDLSTICKSANDWICH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_162CDLSTICKSANDWICH}; static PyObject *__pyx_pw_5talib_7_ta_lib_163CDLSTICKSANDWICH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -23622,7 +22918,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2476, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2476, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -23645,7 +22941,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLSTICKSANDWICH", 0) < 0) __PYX_ERR(4, 2476, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLSTICKSANDWICH", 0) < (0)) __PYX_ERR(4, 2476, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLSTICKSANDWICH", 1, 4, 4, i); __PYX_ERR(4, 2476, __pyx_L3_error) } } @@ -23745,7 +23041,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_162CDLSTICKSANDWICH(CYTHON_UNUSED PyOb __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2499, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2499, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2500, __pyx_L1_error) @@ -23797,7 +23093,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_164CDLTAKURI, "CDLTAKURI(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLTAKURI(open, high, low, close)\n\nTakuri (Dragonfly Doji with very long lower shadow) (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_164CDLTAKURI, "CDLTAKURI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLTAKURI(open, high, low, close)\n\nTakuri (Dragonfly Doji with very long lower shadow) (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_165CDLTAKURI = {"CDLTAKURI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_165CDLTAKURI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_164CDLTAKURI}; static PyObject *__pyx_pw_5talib_7_ta_lib_165CDLTAKURI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -23832,7 +23128,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2508, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2508, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -23855,7 +23151,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLTAKURI", 0) < 0) __PYX_ERR(4, 2508, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLTAKURI", 0) < (0)) __PYX_ERR(4, 2508, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLTAKURI", 1, 4, 4, i); __PYX_ERR(4, 2508, __pyx_L3_error) } } @@ -23955,7 +23251,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_164CDLTAKURI(CYTHON_UNUSED PyObject *_ __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2531, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2531, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2532, __pyx_L1_error) @@ -24007,7 +23303,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_166CDLTASUKIGAP, "CDLTASUKIGAP(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLTASUKIGAP(open, high, low, close)\n\nTasuki Gap (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_166CDLTASUKIGAP, "CDLTASUKIGAP(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLTASUKIGAP(open, high, low, close)\n\nTasuki Gap (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_167CDLTASUKIGAP = {"CDLTASUKIGAP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_167CDLTASUKIGAP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_166CDLTASUKIGAP}; static PyObject *__pyx_pw_5talib_7_ta_lib_167CDLTASUKIGAP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -24042,7 +23338,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2540, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2540, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -24065,7 +23361,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLTASUKIGAP", 0) < 0) __PYX_ERR(4, 2540, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLTASUKIGAP", 0) < (0)) __PYX_ERR(4, 2540, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLTASUKIGAP", 1, 4, 4, i); __PYX_ERR(4, 2540, __pyx_L3_error) } } @@ -24165,7 +23461,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_166CDLTASUKIGAP(CYTHON_UNUSED PyObject __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2563, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2563, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2564, __pyx_L1_error) @@ -24217,7 +23513,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_168CDLTHRUSTING, "CDLTHRUSTING(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLTHRUSTING(open, high, low, close)\n\nThrusting Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_168CDLTHRUSTING, "CDLTHRUSTING(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLTHRUSTING(open, high, low, close)\n\nThrusting Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_169CDLTHRUSTING = {"CDLTHRUSTING", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_169CDLTHRUSTING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_168CDLTHRUSTING}; static PyObject *__pyx_pw_5talib_7_ta_lib_169CDLTHRUSTING(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -24252,7 +23548,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2572, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2572, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -24275,7 +23571,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLTHRUSTING", 0) < 0) __PYX_ERR(4, 2572, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLTHRUSTING", 0) < (0)) __PYX_ERR(4, 2572, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLTHRUSTING", 1, 4, 4, i); __PYX_ERR(4, 2572, __pyx_L3_error) } } @@ -24375,7 +23671,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_168CDLTHRUSTING(CYTHON_UNUSED PyObject __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2595, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2595, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2596, __pyx_L1_error) @@ -24427,7 +23723,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_170CDLTRISTAR, "CDLTRISTAR(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLTRISTAR(open, high, low, close)\n\nTristar Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_170CDLTRISTAR, "CDLTRISTAR(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLTRISTAR(open, high, low, close)\n\nTristar Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_171CDLTRISTAR = {"CDLTRISTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_171CDLTRISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_170CDLTRISTAR}; static PyObject *__pyx_pw_5talib_7_ta_lib_171CDLTRISTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -24462,7 +23758,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2604, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2604, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -24485,7 +23781,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLTRISTAR", 0) < 0) __PYX_ERR(4, 2604, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLTRISTAR", 0) < (0)) __PYX_ERR(4, 2604, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLTRISTAR", 1, 4, 4, i); __PYX_ERR(4, 2604, __pyx_L3_error) } } @@ -24585,7 +23881,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_170CDLTRISTAR(CYTHON_UNUSED PyObject * __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2627, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2627, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2628, __pyx_L1_error) @@ -24637,7 +23933,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_172CDLUNIQUE3RIVER, "CDLUNIQUE3RIVER(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLUNIQUE3RIVER(open, high, low, close)\n\nUnique 3 River (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_172CDLUNIQUE3RIVER, "CDLUNIQUE3RIVER(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLUNIQUE3RIVER(open, high, low, close)\n\nUnique 3 River (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_173CDLUNIQUE3RIVER = {"CDLUNIQUE3RIVER", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_173CDLUNIQUE3RIVER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_172CDLUNIQUE3RIVER}; static PyObject *__pyx_pw_5talib_7_ta_lib_173CDLUNIQUE3RIVER(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -24672,7 +23968,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2636, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2636, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -24695,7 +23991,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLUNIQUE3RIVER", 0) < 0) __PYX_ERR(4, 2636, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLUNIQUE3RIVER", 0) < (0)) __PYX_ERR(4, 2636, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLUNIQUE3RIVER", 1, 4, 4, i); __PYX_ERR(4, 2636, __pyx_L3_error) } } @@ -24795,7 +24091,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_172CDLUNIQUE3RIVER(CYTHON_UNUSED PyObj __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2659, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2659, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2660, __pyx_L1_error) @@ -24847,7 +24143,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_174CDLUPSIDEGAP2CROWS, "CDLUPSIDEGAP2CROWS(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLUPSIDEGAP2CROWS(open, high, low, close)\n\nUpside Gap Two Crows (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_174CDLUPSIDEGAP2CROWS, "CDLUPSIDEGAP2CROWS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLUPSIDEGAP2CROWS(open, high, low, close)\n\nUpside Gap Two Crows (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_175CDLUPSIDEGAP2CROWS = {"CDLUPSIDEGAP2CROWS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_175CDLUPSIDEGAP2CROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_174CDLUPSIDEGAP2CROWS}; static PyObject *__pyx_pw_5talib_7_ta_lib_175CDLUPSIDEGAP2CROWS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -24882,7 +24178,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2668, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2668, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -24905,7 +24201,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLUPSIDEGAP2CROWS", 0) < 0) __PYX_ERR(4, 2668, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLUPSIDEGAP2CROWS", 0) < (0)) __PYX_ERR(4, 2668, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLUPSIDEGAP2CROWS", 1, 4, 4, i); __PYX_ERR(4, 2668, __pyx_L3_error) } } @@ -25005,7 +24301,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_174CDLUPSIDEGAP2CROWS(CYTHON_UNUSED Py __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2691, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2691, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2692, __pyx_L1_error) @@ -25057,7 +24353,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_176CDLXSIDEGAP3METHODS, "CDLXSIDEGAP3METHODS(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLXSIDEGAP3METHODS(open, high, low, close)\n\nUpside/Downside Gap Three Methods (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_176CDLXSIDEGAP3METHODS, "CDLXSIDEGAP3METHODS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLXSIDEGAP3METHODS(open, high, low, close)\n\nUpside/Downside Gap Three Methods (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_177CDLXSIDEGAP3METHODS = {"CDLXSIDEGAP3METHODS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_177CDLXSIDEGAP3METHODS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_176CDLXSIDEGAP3METHODS}; static PyObject *__pyx_pw_5talib_7_ta_lib_177CDLXSIDEGAP3METHODS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -25092,7 +24388,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2700, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2700, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -25115,7 +24411,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLXSIDEGAP3METHODS", 0) < 0) __PYX_ERR(4, 2700, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLXSIDEGAP3METHODS", 0) < (0)) __PYX_ERR(4, 2700, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLXSIDEGAP3METHODS", 1, 4, 4, i); __PYX_ERR(4, 2700, __pyx_L3_error) } } @@ -25215,7 +24511,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_176CDLXSIDEGAP3METHODS(CYTHON_UNUSED P __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2723, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2723, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2724, __pyx_L1_error) @@ -25267,7 +24563,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_178CEIL, "CEIL(ndarray real)\nCEIL(real)\n\nVector Ceil (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_178CEIL, "CEIL(ndarray real)\n\nCEIL(real)\n\nVector Ceil (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_179CEIL = {"CEIL", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_179CEIL, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_178CEIL}; static PyObject *__pyx_pw_5talib_7_ta_lib_179CEIL(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -25299,7 +24595,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2732, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2732, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -25310,7 +24606,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CEIL", 0) < 0) __PYX_ERR(4, 2732, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CEIL", 0) < (0)) __PYX_ERR(4, 2732, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CEIL", 1, 1, 1, i); __PYX_ERR(4, 2732, __pyx_L3_error) } } @@ -25427,7 +24723,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_180CMO, "CMO(ndarray real, int timeperiod=-0x80000000)\nCMO(real[, timeperiod=?])\n\nChande Momentum Oscillator (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_180CMO, "CMO(ndarray real, int timeperiod=-0x80000000)\n\nCMO(real[, timeperiod=?])\n\nChande Momentum Oscillator (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_181CMO = {"CMO", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_181CMO, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_180CMO}; static PyObject *__pyx_pw_5talib_7_ta_lib_181CMO(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -25460,7 +24756,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2761, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2761, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -25475,7 +24771,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CMO", 0) < 0) __PYX_ERR(4, 2761, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CMO", 0) < (0)) __PYX_ERR(4, 2761, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CMO", 0, 1, 2, i); __PYX_ERR(4, 2761, __pyx_L3_error) } } @@ -25604,7 +24900,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_182CORREL, "CORREL(ndarray real0, ndarray real1, int timeperiod=-0x80000000)\nCORREL(real0, real1[, timeperiod=?])\n\nPearson's Correlation Coefficient (r) (Statistic Functions)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_182CORREL, "CORREL(ndarray real0, ndarray real1, int timeperiod=-0x80000000)\n\nCORREL(real0, real1[, timeperiod=?])\n\nPearson's Correlation Coefficient (r) (Statistic Functions)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_183CORREL = {"CORREL", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_183CORREL, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_182CORREL}; static PyObject *__pyx_pw_5talib_7_ta_lib_183CORREL(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -25638,7 +24934,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2792, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2792, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -25657,7 +24953,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CORREL", 0) < 0) __PYX_ERR(4, 2792, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CORREL", 0) < (0)) __PYX_ERR(4, 2792, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CORREL", 0, 2, 3, i); __PYX_ERR(4, 2792, __pyx_L3_error) } } @@ -25749,7 +25045,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_182CORREL(CYTHON_UNUSED PyObject *__py __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2816, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2816, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2817, __pyx_L1_error) @@ -25799,7 +25095,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_184COS, "COS(ndarray real)\nCOS(real)\n\nVector Trigonometric Cos (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_184COS, "COS(ndarray real)\n\nCOS(real)\n\nVector Trigonometric Cos (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_185COS = {"COS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_185COS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_184COS}; static PyObject *__pyx_pw_5talib_7_ta_lib_185COS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -25831,7 +25127,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2825, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2825, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -25842,7 +25138,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "COS", 0) < 0) __PYX_ERR(4, 2825, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "COS", 0) < (0)) __PYX_ERR(4, 2825, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("COS", 1, 1, 1, i); __PYX_ERR(4, 2825, __pyx_L3_error) } } @@ -25959,7 +25255,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_186COSH, "COSH(ndarray real)\nCOSH(real)\n\nVector Trigonometric Cosh (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_186COSH, "COSH(ndarray real)\n\nCOSH(real)\n\nVector Trigonometric Cosh (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_187COSH = {"COSH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_187COSH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_186COSH}; static PyObject *__pyx_pw_5talib_7_ta_lib_187COSH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -25991,7 +25287,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2854, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2854, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -26002,7 +25298,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "COSH", 0) < 0) __PYX_ERR(4, 2854, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "COSH", 0) < (0)) __PYX_ERR(4, 2854, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("COSH", 1, 1, 1, i); __PYX_ERR(4, 2854, __pyx_L3_error) } } @@ -26119,7 +25415,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_188DEMA, "DEMA(ndarray real, int timeperiod=-0x80000000)\nDEMA(real[, timeperiod=?])\n\nDouble Exponential Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_188DEMA, "DEMA(ndarray real, int timeperiod=-0x80000000)\n\nDEMA(real[, timeperiod=?])\n\nDouble Exponential Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_189DEMA = {"DEMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_189DEMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_188DEMA}; static PyObject *__pyx_pw_5talib_7_ta_lib_189DEMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -26152,7 +25448,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2883, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2883, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -26167,7 +25463,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "DEMA", 0) < 0) __PYX_ERR(4, 2883, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "DEMA", 0) < (0)) __PYX_ERR(4, 2883, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("DEMA", 0, 1, 2, i); __PYX_ERR(4, 2883, __pyx_L3_error) } } @@ -26296,7 +25592,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_190DIV, "DIV(ndarray real0, ndarray real1)\nDIV(real0, real1)\n\nVector Arithmetic Div (Math Operators)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_190DIV, "DIV(ndarray real0, ndarray real1)\n\nDIV(real0, real1)\n\nVector Arithmetic Div (Math Operators)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_191DIV = {"DIV", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_191DIV, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_190DIV}; static PyObject *__pyx_pw_5talib_7_ta_lib_191DIV(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -26329,7 +25625,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2914, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2914, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -26344,7 +25640,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "DIV", 0) < 0) __PYX_ERR(4, 2914, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "DIV", 0) < (0)) __PYX_ERR(4, 2914, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("DIV", 1, 2, 2, i); __PYX_ERR(4, 2914, __pyx_L3_error) } } @@ -26424,7 +25720,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_190DIV(CYTHON_UNUSED PyObject *__pyx_s __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2936, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2936, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2937, __pyx_L1_error) @@ -26474,7 +25770,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_192DX, "DX(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\nDX(high, low, close[, timeperiod=?])\n\nDirectional Movement Index (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_192DX, "DX(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nDX(high, low, close[, timeperiod=?])\n\nDirectional Movement Index (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_193DX = {"DX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_193DX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_192DX}; static PyObject *__pyx_pw_5talib_7_ta_lib_193DX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -26509,7 +25805,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2945, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2945, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -26532,7 +25828,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "DX", 0) < 0) __PYX_ERR(4, 2945, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "DX", 0) < (0)) __PYX_ERR(4, 2945, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("DX", 0, 3, 4, i); __PYX_ERR(4, 2945, __pyx_L3_error) } } @@ -26634,7 +25930,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_192DX(CYTHON_UNUSED PyObject *__pyx_se __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2969, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 2969, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2970, __pyx_L1_error) @@ -26685,7 +25981,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_194EMA, "EMA(ndarray real, int timeperiod=-0x80000000)\nEMA(real[, timeperiod=?])\n\nExponential Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_194EMA, "EMA(ndarray real, int timeperiod=-0x80000000)\n\nEMA(real[, timeperiod=?])\n\nExponential Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_195EMA = {"EMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_195EMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_194EMA}; static PyObject *__pyx_pw_5talib_7_ta_lib_195EMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -26718,7 +26014,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2978, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 2978, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -26733,7 +26029,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "EMA", 0) < 0) __PYX_ERR(4, 2978, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "EMA", 0) < (0)) __PYX_ERR(4, 2978, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("EMA", 0, 1, 2, i); __PYX_ERR(4, 2978, __pyx_L3_error) } } @@ -26862,7 +26158,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_196EXP, "EXP(ndarray real)\nEXP(real)\n\nVector Arithmetic Exp (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_196EXP, "EXP(ndarray real)\n\nEXP(real)\n\nVector Arithmetic Exp (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_197EXP = {"EXP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_197EXP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_196EXP}; static PyObject *__pyx_pw_5talib_7_ta_lib_197EXP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -26894,7 +26190,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3009, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3009, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -26905,7 +26201,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "EXP", 0) < 0) __PYX_ERR(4, 3009, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "EXP", 0) < (0)) __PYX_ERR(4, 3009, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("EXP", 1, 1, 1, i); __PYX_ERR(4, 3009, __pyx_L3_error) } } @@ -27022,7 +26318,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_198FLOOR, "FLOOR(ndarray real)\nFLOOR(real)\n\nVector Floor (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_198FLOOR, "FLOOR(ndarray real)\n\nFLOOR(real)\n\nVector Floor (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_199FLOOR = {"FLOOR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_199FLOOR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_198FLOOR}; static PyObject *__pyx_pw_5talib_7_ta_lib_199FLOOR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -27054,7 +26350,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3038, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3038, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -27065,7 +26361,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "FLOOR", 0) < 0) __PYX_ERR(4, 3038, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "FLOOR", 0) < (0)) __PYX_ERR(4, 3038, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("FLOOR", 1, 1, 1, i); __PYX_ERR(4, 3038, __pyx_L3_error) } } @@ -27182,7 +26478,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_200HT_DCPERIOD, "HT_DCPERIOD(ndarray real)\nHT_DCPERIOD(real)\n\nHilbert Transform - Dominant Cycle Period (Cycle Indicators)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_200HT_DCPERIOD, "HT_DCPERIOD(ndarray real)\n\nHT_DCPERIOD(real)\n\nHilbert Transform - Dominant Cycle Period (Cycle Indicators)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_201HT_DCPERIOD = {"HT_DCPERIOD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_201HT_DCPERIOD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_200HT_DCPERIOD}; static PyObject *__pyx_pw_5talib_7_ta_lib_201HT_DCPERIOD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -27214,7 +26510,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3067, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3067, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -27225,7 +26521,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "HT_DCPERIOD", 0) < 0) __PYX_ERR(4, 3067, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "HT_DCPERIOD", 0) < (0)) __PYX_ERR(4, 3067, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("HT_DCPERIOD", 1, 1, 1, i); __PYX_ERR(4, 3067, __pyx_L3_error) } } @@ -27342,7 +26638,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_202HT_DCPHASE, "HT_DCPHASE(ndarray real)\nHT_DCPHASE(real)\n\nHilbert Transform - Dominant Cycle Phase (Cycle Indicators)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_202HT_DCPHASE, "HT_DCPHASE(ndarray real)\n\nHT_DCPHASE(real)\n\nHilbert Transform - Dominant Cycle Phase (Cycle Indicators)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_203HT_DCPHASE = {"HT_DCPHASE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_203HT_DCPHASE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_202HT_DCPHASE}; static PyObject *__pyx_pw_5talib_7_ta_lib_203HT_DCPHASE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -27374,7 +26670,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3096, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3096, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -27385,7 +26681,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "HT_DCPHASE", 0) < 0) __PYX_ERR(4, 3096, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "HT_DCPHASE", 0) < (0)) __PYX_ERR(4, 3096, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("HT_DCPHASE", 1, 1, 1, i); __PYX_ERR(4, 3096, __pyx_L3_error) } } @@ -27502,7 +26798,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_204HT_PHASOR, "HT_PHASOR(ndarray real)\nHT_PHASOR(real)\n\nHilbert Transform - Phasor Components (Cycle Indicators)\n\nInputs:\n real: (any ndarray)\nOutputs:\n inphase\n quadrature"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_204HT_PHASOR, "HT_PHASOR(ndarray real)\n\nHT_PHASOR(real)\n\nHilbert Transform - Phasor Components (Cycle Indicators)\n\nInputs:\n real: (any ndarray)\nOutputs:\n inphase\n quadrature"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_205HT_PHASOR = {"HT_PHASOR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_205HT_PHASOR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_204HT_PHASOR}; static PyObject *__pyx_pw_5talib_7_ta_lib_205HT_PHASOR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -27534,7 +26830,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3125, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3125, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -27545,7 +26841,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "HT_PHASOR", 0) < 0) __PYX_ERR(4, 3125, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "HT_PHASOR", 0) < (0)) __PYX_ERR(4, 3125, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("HT_PHASOR", 1, 1, 1, i); __PYX_ERR(4, 3125, __pyx_L3_error) } } @@ -27677,7 +26973,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_206HT_SINE, "HT_SINE(ndarray real)\nHT_SINE(real)\n\nHilbert Transform - SineWave (Cycle Indicators)\n\nInputs:\n real: (any ndarray)\nOutputs:\n sine\n leadsine"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_206HT_SINE, "HT_SINE(ndarray real)\n\nHT_SINE(real)\n\nHilbert Transform - SineWave (Cycle Indicators)\n\nInputs:\n real: (any ndarray)\nOutputs:\n sine\n leadsine"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_207HT_SINE = {"HT_SINE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_207HT_SINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_206HT_SINE}; static PyObject *__pyx_pw_5talib_7_ta_lib_207HT_SINE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -27709,7 +27005,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3157, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3157, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -27720,7 +27016,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "HT_SINE", 0) < 0) __PYX_ERR(4, 3157, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "HT_SINE", 0) < (0)) __PYX_ERR(4, 3157, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("HT_SINE", 1, 1, 1, i); __PYX_ERR(4, 3157, __pyx_L3_error) } } @@ -27852,7 +27148,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_208HT_TRENDLINE, "HT_TRENDLINE(ndarray real)\nHT_TRENDLINE(real)\n\nHilbert Transform - Instantaneous Trendline (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_208HT_TRENDLINE, "HT_TRENDLINE(ndarray real)\n\nHT_TRENDLINE(real)\n\nHilbert Transform - Instantaneous Trendline (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_209HT_TRENDLINE = {"HT_TRENDLINE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_209HT_TRENDLINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_208HT_TRENDLINE}; static PyObject *__pyx_pw_5talib_7_ta_lib_209HT_TRENDLINE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -27884,7 +27180,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3189, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3189, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -27895,7 +27191,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "HT_TRENDLINE", 0) < 0) __PYX_ERR(4, 3189, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "HT_TRENDLINE", 0) < (0)) __PYX_ERR(4, 3189, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("HT_TRENDLINE", 1, 1, 1, i); __PYX_ERR(4, 3189, __pyx_L3_error) } } @@ -28012,7 +27308,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_210HT_TRENDMODE, "HT_TRENDMODE(ndarray real)\nHT_TRENDMODE(real)\n\nHilbert Transform - Trend vs Cycle Mode (Cycle Indicators)\n\nInputs:\n real: (any ndarray)\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_210HT_TRENDMODE, "HT_TRENDMODE(ndarray real)\n\nHT_TRENDMODE(real)\n\nHilbert Transform - Trend vs Cycle Mode (Cycle Indicators)\n\nInputs:\n real: (any ndarray)\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_211HT_TRENDMODE = {"HT_TRENDMODE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_211HT_TRENDMODE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_210HT_TRENDMODE}; static PyObject *__pyx_pw_5talib_7_ta_lib_211HT_TRENDMODE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -28044,7 +27340,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3218, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3218, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -28055,7 +27351,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "HT_TRENDMODE", 0) < 0) __PYX_ERR(4, 3218, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "HT_TRENDMODE", 0) < (0)) __PYX_ERR(4, 3218, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("HT_TRENDMODE", 1, 1, 1, i); __PYX_ERR(4, 3218, __pyx_L3_error) } } @@ -28172,7 +27468,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_212IMI, "IMI(ndarray open, ndarray close, int timeperiod=-0x80000000)\nIMI(open, close[, timeperiod=?])\n\nIntraday Momentum Index (Momentum Indicators)\n\nInputs:\n prices: ['open', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_212IMI, "IMI(ndarray open, ndarray close, int timeperiod=-0x80000000)\n\nIMI(open, close[, timeperiod=?])\n\nIntraday Momentum Index (Momentum Indicators)\n\nInputs:\n prices: ['open', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_213IMI = {"IMI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_213IMI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_212IMI}; static PyObject *__pyx_pw_5talib_7_ta_lib_213IMI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -28206,7 +27502,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3247, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3247, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -28225,7 +27521,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "IMI", 0) < 0) __PYX_ERR(4, 3247, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "IMI", 0) < (0)) __PYX_ERR(4, 3247, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("IMI", 0, 2, 3, i); __PYX_ERR(4, 3247, __pyx_L3_error) } } @@ -28317,7 +27613,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_212IMI(CYTHON_UNUSED PyObject *__pyx_s __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_open, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 3270, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_open, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 3270, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3271, __pyx_L1_error) @@ -28367,7 +27663,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_214KAMA, "KAMA(ndarray real, int timeperiod=-0x80000000)\nKAMA(real[, timeperiod=?])\n\nKaufman Adaptive Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_214KAMA, "KAMA(ndarray real, int timeperiod=-0x80000000)\n\nKAMA(real[, timeperiod=?])\n\nKaufman Adaptive Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_215KAMA = {"KAMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_215KAMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_214KAMA}; static PyObject *__pyx_pw_5talib_7_ta_lib_215KAMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -28400,7 +27696,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3279, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3279, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -28415,7 +27711,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "KAMA", 0) < 0) __PYX_ERR(4, 3279, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "KAMA", 0) < (0)) __PYX_ERR(4, 3279, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("KAMA", 0, 1, 2, i); __PYX_ERR(4, 3279, __pyx_L3_error) } } @@ -28544,7 +27840,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_216LINEARREG, "LINEARREG(ndarray real, int timeperiod=-0x80000000)\nLINEARREG(real[, timeperiod=?])\n\nLinear Regression (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_216LINEARREG, "LINEARREG(ndarray real, int timeperiod=-0x80000000)\n\nLINEARREG(real[, timeperiod=?])\n\nLinear Regression (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_217LINEARREG = {"LINEARREG", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_217LINEARREG, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_216LINEARREG}; static PyObject *__pyx_pw_5talib_7_ta_lib_217LINEARREG(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -28577,7 +27873,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3310, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3310, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -28592,7 +27888,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "LINEARREG", 0) < 0) __PYX_ERR(4, 3310, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "LINEARREG", 0) < (0)) __PYX_ERR(4, 3310, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("LINEARREG", 0, 1, 2, i); __PYX_ERR(4, 3310, __pyx_L3_error) } } @@ -28721,7 +28017,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_218LINEARREG_ANGLE, "LINEARREG_ANGLE(ndarray real, int timeperiod=-0x80000000)\nLINEARREG_ANGLE(real[, timeperiod=?])\n\nLinear Regression Angle (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_218LINEARREG_ANGLE, "LINEARREG_ANGLE(ndarray real, int timeperiod=-0x80000000)\n\nLINEARREG_ANGLE(real[, timeperiod=?])\n\nLinear Regression Angle (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_219LINEARREG_ANGLE = {"LINEARREG_ANGLE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_219LINEARREG_ANGLE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_218LINEARREG_ANGLE}; static PyObject *__pyx_pw_5talib_7_ta_lib_219LINEARREG_ANGLE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -28754,7 +28050,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3341, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3341, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -28769,7 +28065,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "LINEARREG_ANGLE", 0) < 0) __PYX_ERR(4, 3341, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "LINEARREG_ANGLE", 0) < (0)) __PYX_ERR(4, 3341, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("LINEARREG_ANGLE", 0, 1, 2, i); __PYX_ERR(4, 3341, __pyx_L3_error) } } @@ -28898,7 +28194,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_220LINEARREG_INTERCEPT, "LINEARREG_INTERCEPT(ndarray real, int timeperiod=-0x80000000)\nLINEARREG_INTERCEPT(real[, timeperiod=?])\n\nLinear Regression Intercept (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_220LINEARREG_INTERCEPT, "LINEARREG_INTERCEPT(ndarray real, int timeperiod=-0x80000000)\n\nLINEARREG_INTERCEPT(real[, timeperiod=?])\n\nLinear Regression Intercept (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_221LINEARREG_INTERCEPT = {"LINEARREG_INTERCEPT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_221LINEARREG_INTERCEPT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_220LINEARREG_INTERCEPT}; static PyObject *__pyx_pw_5talib_7_ta_lib_221LINEARREG_INTERCEPT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -28931,7 +28227,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3372, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3372, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -28946,7 +28242,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "LINEARREG_INTERCEPT", 0) < 0) __PYX_ERR(4, 3372, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "LINEARREG_INTERCEPT", 0) < (0)) __PYX_ERR(4, 3372, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("LINEARREG_INTERCEPT", 0, 1, 2, i); __PYX_ERR(4, 3372, __pyx_L3_error) } } @@ -29075,7 +28371,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_222LINEARREG_SLOPE, "LINEARREG_SLOPE(ndarray real, int timeperiod=-0x80000000)\nLINEARREG_SLOPE(real[, timeperiod=?])\n\nLinear Regression Slope (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_222LINEARREG_SLOPE, "LINEARREG_SLOPE(ndarray real, int timeperiod=-0x80000000)\n\nLINEARREG_SLOPE(real[, timeperiod=?])\n\nLinear Regression Slope (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_223LINEARREG_SLOPE = {"LINEARREG_SLOPE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_223LINEARREG_SLOPE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_222LINEARREG_SLOPE}; static PyObject *__pyx_pw_5talib_7_ta_lib_223LINEARREG_SLOPE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -29108,7 +28404,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3403, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3403, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -29123,7 +28419,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "LINEARREG_SLOPE", 0) < 0) __PYX_ERR(4, 3403, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "LINEARREG_SLOPE", 0) < (0)) __PYX_ERR(4, 3403, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("LINEARREG_SLOPE", 0, 1, 2, i); __PYX_ERR(4, 3403, __pyx_L3_error) } } @@ -29252,7 +28548,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_224LN, "LN(ndarray real)\nLN(real)\n\nVector Log Natural (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_224LN, "LN(ndarray real)\n\nLN(real)\n\nVector Log Natural (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_225LN = {"LN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_225LN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_224LN}; static PyObject *__pyx_pw_5talib_7_ta_lib_225LN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -29284,7 +28580,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3434, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3434, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -29295,7 +28591,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "LN", 0) < 0) __PYX_ERR(4, 3434, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "LN", 0) < (0)) __PYX_ERR(4, 3434, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("LN", 1, 1, 1, i); __PYX_ERR(4, 3434, __pyx_L3_error) } } @@ -29412,7 +28708,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_226LOG10, "LOG10(ndarray real)\nLOG10(real)\n\nVector Log10 (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_226LOG10, "LOG10(ndarray real)\n\nLOG10(real)\n\nVector Log10 (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_227LOG10 = {"LOG10", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_227LOG10, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_226LOG10}; static PyObject *__pyx_pw_5talib_7_ta_lib_227LOG10(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -29444,7 +28740,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3463, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3463, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -29455,7 +28751,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "LOG10", 0) < 0) __PYX_ERR(4, 3463, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "LOG10", 0) < (0)) __PYX_ERR(4, 3463, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("LOG10", 1, 1, 1, i); __PYX_ERR(4, 3463, __pyx_L3_error) } } @@ -29572,7 +28868,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_228MA, "MA(ndarray real, int timeperiod=-0x80000000, int matype=0)\nMA(real[, timeperiod=?, matype=?])\n\nMoving average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\n matype: 0 (Simple Moving Average)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_228MA, "MA(ndarray real, int timeperiod=-0x80000000, int matype=0)\n\nMA(real[, timeperiod=?, matype=?])\n\nMoving average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\n matype: 0 (Simple Moving Average)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_229MA = {"MA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_229MA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_228MA}; static PyObject *__pyx_pw_5talib_7_ta_lib_229MA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -29606,7 +28902,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_matype,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3492, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3492, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -29625,7 +28921,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MA", 0) < 0) __PYX_ERR(4, 3492, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MA", 0) < (0)) __PYX_ERR(4, 3492, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MA", 0, 1, 3, i); __PYX_ERR(4, 3492, __pyx_L3_error) } } @@ -29763,7 +29059,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_230MACD, "MACD(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int signalperiod=-0x80000000)\nMACD(real[, fastperiod=?, slowperiod=?, signalperiod=?])\n\nMoving Average Convergence/Divergence (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n fastperiod: 12\n slowperiod: 26\n signalperiod: 9\nOutputs:\n macd\n macdsignal\n macdhist"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_230MACD, "MACD(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int signalperiod=-0x80000000)\n\nMACD(real[, fastperiod=?, slowperiod=?, signalperiod=?])\n\nMoving Average Convergence/Divergence (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n fastperiod: 12\n slowperiod: 26\n signalperiod: 9\nOutputs:\n macd\n macdsignal\n macdhist"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_231MACD = {"MACD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_231MACD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_230MACD}; static PyObject *__pyx_pw_5talib_7_ta_lib_231MACD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -29798,7 +29094,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_fastperiod,&__pyx_mstate_global->__pyx_n_u_slowperiod,&__pyx_mstate_global->__pyx_n_u_signalperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3524, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3524, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -29821,7 +29117,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MACD", 0) < 0) __PYX_ERR(4, 3524, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MACD", 0) < (0)) __PYX_ERR(4, 3524, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MACD", 0, 1, 4, i); __PYX_ERR(4, 3524, __pyx_L3_error) } } @@ -29993,7 +29289,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_232MACDEXT, "MACDEXT(ndarray real, int fastperiod=-0x80000000, int fastmatype=0, int slowperiod=-0x80000000, int slowmatype=0, int signalperiod=-0x80000000, int signalmatype=0)\nMACDEXT(real[, fastperiod=?, fastmatype=?, slowperiod=?, slowmatype=?, signalperiod=?, signalmatype=?])\n\nMACD with controllable MA type (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n fastperiod: 12\n fastmatype: 0\n slowperiod: 26\n slowmatype: 0\n signalperiod: 9\n signalmatype: 0\nOutputs:\n macd\n macdsignal\n macdhist"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_232MACDEXT, "MACDEXT(ndarray real, int fastperiod=-0x80000000, int fastmatype=0, int slowperiod=-0x80000000, int slowmatype=0, int signalperiod=-0x80000000, int signalmatype=0)\n\nMACDEXT(real[, fastperiod=?, fastmatype=?, slowperiod=?, slowmatype=?, signalperiod=?, signalmatype=?])\n\nMACD with controllable MA type (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n fastperiod: 12\n fastmatype: 0\n slowperiod: 26\n slowmatype: 0\n signalperiod: 9\n signalmatype: 0\nOutputs:\n macd\n macdsignal\n macdhist"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_233MACDEXT = {"MACDEXT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_233MACDEXT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_232MACDEXT}; static PyObject *__pyx_pw_5talib_7_ta_lib_233MACDEXT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -30031,7 +29327,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_fastperiod,&__pyx_mstate_global->__pyx_n_u_fastmatype,&__pyx_mstate_global->__pyx_n_u_slowperiod,&__pyx_mstate_global->__pyx_n_u_slowmatype,&__pyx_mstate_global->__pyx_n_u_signalperiod,&__pyx_mstate_global->__pyx_n_u_signalmatype,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3563, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3563, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 7: @@ -30066,7 +29362,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MACDEXT", 0) < 0) __PYX_ERR(4, 3563, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MACDEXT", 0) < (0)) __PYX_ERR(4, 3563, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MACDEXT", 0, 1, 7, i); __PYX_ERR(4, 3563, __pyx_L3_error) } } @@ -30265,7 +29561,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_234MACDFIX, "MACDFIX(ndarray real, int signalperiod=-0x80000000)\nMACDFIX(real[, signalperiod=?])\n\nMoving Average Convergence/Divergence Fix 12/26 (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n signalperiod: 9\nOutputs:\n macd\n macdsignal\n macdhist"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_234MACDFIX, "MACDFIX(ndarray real, int signalperiod=-0x80000000)\n\nMACDFIX(real[, signalperiod=?])\n\nMoving Average Convergence/Divergence Fix 12/26 (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n signalperiod: 9\nOutputs:\n macd\n macdsignal\n macdhist"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_235MACDFIX = {"MACDFIX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_235MACDFIX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_234MACDFIX}; static PyObject *__pyx_pw_5talib_7_ta_lib_235MACDFIX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -30298,7 +29594,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_signalperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3605, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3605, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -30313,7 +29609,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MACDFIX", 0) < 0) __PYX_ERR(4, 3605, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MACDFIX", 0) < (0)) __PYX_ERR(4, 3605, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MACDFIX", 0, 1, 2, i); __PYX_ERR(4, 3605, __pyx_L3_error) } } @@ -30467,7 +29763,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_236MAMA, "MAMA(ndarray real, double fastlimit=-4e37, double slowlimit=-4e37)\nMAMA(real[, fastlimit=?, slowlimit=?])\n\nMESA Adaptive Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n fastlimit: 0.5\n slowlimit: 0.05\nOutputs:\n mama\n fama"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_236MAMA, "MAMA(ndarray real, double fastlimit=-4e37, double slowlimit=-4e37)\n\nMAMA(real[, fastlimit=?, slowlimit=?])\n\nMESA Adaptive Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n fastlimit: 0.5\n slowlimit: 0.05\nOutputs:\n mama\n fama"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_237MAMA = {"MAMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_237MAMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_236MAMA}; static PyObject *__pyx_pw_5talib_7_ta_lib_237MAMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -30501,7 +29797,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_fastlimit,&__pyx_mstate_global->__pyx_n_u_slowlimit,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3642, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3642, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -30520,7 +29816,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MAMA", 0) < 0) __PYX_ERR(4, 3642, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MAMA", 0) < (0)) __PYX_ERR(4, 3642, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MAMA", 0, 1, 3, i); __PYX_ERR(4, 3642, __pyx_L3_error) } } @@ -30673,7 +29969,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_238MAVP, "MAVP(ndarray real, ndarray periods, int minperiod=-0x80000000, int maxperiod=-0x80000000, int matype=0)\nMAVP(real, periods[, minperiod=?, maxperiod=?, matype=?])\n\nMoving average with variable period (Overlap Studies)\n\nInputs:\n real: (any ndarray)\n periods: (any ndarray)\nParameters:\n minperiod: 2\n maxperiod: 30\n matype: 0 (Simple Moving Average)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_238MAVP, "MAVP(ndarray real, ndarray periods, int minperiod=-0x80000000, int maxperiod=-0x80000000, int matype=0)\n\nMAVP(real, periods[, minperiod=?, maxperiod=?, matype=?])\n\nMoving average with variable period (Overlap Studies)\n\nInputs:\n real: (any ndarray)\n periods: (any ndarray)\nParameters:\n minperiod: 2\n maxperiod: 30\n matype: 0 (Simple Moving Average)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_239MAVP = {"MAVP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_239MAVP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_238MAVP}; static PyObject *__pyx_pw_5talib_7_ta_lib_239MAVP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -30709,7 +30005,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_periods,&__pyx_mstate_global->__pyx_n_u_minperiod,&__pyx_mstate_global->__pyx_n_u_maxperiod,&__pyx_mstate_global->__pyx_n_u_matype,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3677, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3677, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 5: @@ -30736,7 +30032,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MAVP", 0) < 0) __PYX_ERR(4, 3677, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MAVP", 0) < (0)) __PYX_ERR(4, 3677, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MAVP", 0, 2, 5, i); __PYX_ERR(4, 3677, __pyx_L3_error) } } @@ -30846,7 +30142,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_238MAVP(CYTHON_UNUSED PyObject *__pyx_ __Pyx_DECREF_SET(__pyx_v_periods, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real, __pyx_v_periods); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 3703, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real, __pyx_v_periods); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 3703, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_periods))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3704, __pyx_L1_error) @@ -30896,7 +30192,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_240MAX, "MAX(ndarray real, int timeperiod=-0x80000000)\nMAX(real[, timeperiod=?])\n\nHighest value over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_240MAX, "MAX(ndarray real, int timeperiod=-0x80000000)\n\nMAX(real[, timeperiod=?])\n\nHighest value over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_241MAX = {"MAX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_241MAX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_240MAX}; static PyObject *__pyx_pw_5talib_7_ta_lib_241MAX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -30929,7 +30225,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3712, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3712, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -30944,7 +30240,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MAX", 0) < 0) __PYX_ERR(4, 3712, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MAX", 0) < (0)) __PYX_ERR(4, 3712, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MAX", 0, 1, 2, i); __PYX_ERR(4, 3712, __pyx_L3_error) } } @@ -31073,7 +30369,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_242MAXINDEX, "MAXINDEX(ndarray real, int timeperiod=-0x80000000)\nMAXINDEX(real[, timeperiod=?])\n\nIndex of highest value over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_242MAXINDEX, "MAXINDEX(ndarray real, int timeperiod=-0x80000000)\n\nMAXINDEX(real[, timeperiod=?])\n\nIndex of highest value over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_243MAXINDEX = {"MAXINDEX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_243MAXINDEX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_242MAXINDEX}; static PyObject *__pyx_pw_5talib_7_ta_lib_243MAXINDEX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -31106,7 +30402,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3743, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3743, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -31121,7 +30417,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MAXINDEX", 0) < 0) __PYX_ERR(4, 3743, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MAXINDEX", 0) < (0)) __PYX_ERR(4, 3743, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MAXINDEX", 0, 1, 2, i); __PYX_ERR(4, 3743, __pyx_L3_error) } } @@ -31263,7 +30559,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_244MEDPRICE, "MEDPRICE(ndarray high, ndarray low)\nMEDPRICE(high, low)\n\nMedian Price (Price Transform)\n\nInputs:\n prices: ['high', 'low']\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_244MEDPRICE, "MEDPRICE(ndarray high, ndarray low)\n\nMEDPRICE(high, low)\n\nMedian Price (Price Transform)\n\nInputs:\n prices: ['high', 'low']\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_245MEDPRICE = {"MEDPRICE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_245MEDPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_244MEDPRICE}; static PyObject *__pyx_pw_5talib_7_ta_lib_245MEDPRICE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -31296,7 +30592,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3777, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3777, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -31311,7 +30607,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MEDPRICE", 0) < 0) __PYX_ERR(4, 3777, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MEDPRICE", 0) < (0)) __PYX_ERR(4, 3777, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MEDPRICE", 1, 2, 2, i); __PYX_ERR(4, 3777, __pyx_L3_error) } } @@ -31391,7 +30687,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_244MEDPRICE(CYTHON_UNUSED PyObject *__ __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 3798, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 3798, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3799, __pyx_L1_error) @@ -31441,7 +30737,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_246MFI, "MFI(ndarray high, ndarray low, ndarray close, ndarray volume, int timeperiod=-0x80000000)\nMFI(high, low, close, volume[, timeperiod=?])\n\nMoney Flow Index (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close', 'volume']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_246MFI, "MFI(ndarray high, ndarray low, ndarray close, ndarray volume, int timeperiod=-0x80000000)\n\nMFI(high, low, close, volume[, timeperiod=?])\n\nMoney Flow Index (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close', 'volume']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_247MFI = {"MFI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_247MFI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_246MFI}; static PyObject *__pyx_pw_5talib_7_ta_lib_247MFI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -31477,7 +30773,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_volume,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3807, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3807, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 5: @@ -31504,7 +30800,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MFI", 0) < 0) __PYX_ERR(4, 3807, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MFI", 0) < (0)) __PYX_ERR(4, 3807, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MFI", 0, 4, 5, i); __PYX_ERR(4, 3807, __pyx_L3_error) } } @@ -31616,7 +30912,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_246MFI(CYTHON_UNUSED PyObject *__pyx_s __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 3832, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 3832, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3833, __pyx_L1_error) @@ -31668,7 +30964,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_248MIDPOINT, "MIDPOINT(ndarray real, int timeperiod=-0x80000000)\nMIDPOINT(real[, timeperiod=?])\n\nMidPoint over period (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_248MIDPOINT, "MIDPOINT(ndarray real, int timeperiod=-0x80000000)\n\nMIDPOINT(real[, timeperiod=?])\n\nMidPoint over period (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_249MIDPOINT = {"MIDPOINT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_249MIDPOINT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_248MIDPOINT}; static PyObject *__pyx_pw_5talib_7_ta_lib_249MIDPOINT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -31701,7 +30997,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3841, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3841, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -31716,7 +31012,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MIDPOINT", 0) < 0) __PYX_ERR(4, 3841, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MIDPOINT", 0) < (0)) __PYX_ERR(4, 3841, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MIDPOINT", 0, 1, 2, i); __PYX_ERR(4, 3841, __pyx_L3_error) } } @@ -31845,7 +31141,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_250MIDPRICE, "MIDPRICE(ndarray high, ndarray low, int timeperiod=-0x80000000)\nMIDPRICE(high, low[, timeperiod=?])\n\nMidpoint Price over period (Overlap Studies)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_250MIDPRICE, "MIDPRICE(ndarray high, ndarray low, int timeperiod=-0x80000000)\n\nMIDPRICE(high, low[, timeperiod=?])\n\nMidpoint Price over period (Overlap Studies)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_251MIDPRICE = {"MIDPRICE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_251MIDPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_250MIDPRICE}; static PyObject *__pyx_pw_5talib_7_ta_lib_251MIDPRICE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -31879,7 +31175,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3872, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3872, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -31898,7 +31194,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MIDPRICE", 0) < 0) __PYX_ERR(4, 3872, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MIDPRICE", 0) < (0)) __PYX_ERR(4, 3872, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MIDPRICE", 0, 2, 3, i); __PYX_ERR(4, 3872, __pyx_L3_error) } } @@ -31990,7 +31286,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_250MIDPRICE(CYTHON_UNUSED PyObject *__ __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 3895, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 3895, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3896, __pyx_L1_error) @@ -32040,7 +31336,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_252MIN, "MIN(ndarray real, int timeperiod=-0x80000000)\nMIN(real[, timeperiod=?])\n\nLowest value over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_252MIN, "MIN(ndarray real, int timeperiod=-0x80000000)\n\nMIN(real[, timeperiod=?])\n\nLowest value over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_253MIN = {"MIN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_253MIN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_252MIN}; static PyObject *__pyx_pw_5talib_7_ta_lib_253MIN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -32073,7 +31369,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3904, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3904, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -32088,7 +31384,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MIN", 0) < 0) __PYX_ERR(4, 3904, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MIN", 0) < (0)) __PYX_ERR(4, 3904, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MIN", 0, 1, 2, i); __PYX_ERR(4, 3904, __pyx_L3_error) } } @@ -32217,7 +31513,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_254MININDEX, "MININDEX(ndarray real, int timeperiod=-0x80000000)\nMININDEX(real[, timeperiod=?])\n\nIndex of lowest value over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_254MININDEX, "MININDEX(ndarray real, int timeperiod=-0x80000000)\n\nMININDEX(real[, timeperiod=?])\n\nIndex of lowest value over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_255MININDEX = {"MININDEX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_255MININDEX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_254MININDEX}; static PyObject *__pyx_pw_5talib_7_ta_lib_255MININDEX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -32250,7 +31546,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3935, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3935, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -32265,7 +31561,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MININDEX", 0) < 0) __PYX_ERR(4, 3935, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MININDEX", 0) < (0)) __PYX_ERR(4, 3935, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MININDEX", 0, 1, 2, i); __PYX_ERR(4, 3935, __pyx_L3_error) } } @@ -32407,7 +31703,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_256MINMAX, "MINMAX(ndarray real, int timeperiod=-0x80000000)\nMINMAX(real[, timeperiod=?])\n\nLowest and highest values over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n min\n max"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_256MINMAX, "MINMAX(ndarray real, int timeperiod=-0x80000000)\n\nMINMAX(real[, timeperiod=?])\n\nLowest and highest values over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n min\n max"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_257MINMAX = {"MINMAX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_257MINMAX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_256MINMAX}; static PyObject *__pyx_pw_5talib_7_ta_lib_257MINMAX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -32440,7 +31736,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3969, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 3969, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -32455,7 +31751,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MINMAX", 0) < 0) __PYX_ERR(4, 3969, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MINMAX", 0) < (0)) __PYX_ERR(4, 3969, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MINMAX", 0, 1, 2, i); __PYX_ERR(4, 3969, __pyx_L3_error) } } @@ -32599,7 +31895,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_258MINMAXINDEX, "MINMAXINDEX(ndarray real, int timeperiod=-0x80000000)\nMINMAXINDEX(real[, timeperiod=?])\n\nIndexes of lowest and highest values over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n minidx\n maxidx"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_258MINMAXINDEX, "MINMAXINDEX(ndarray real, int timeperiod=-0x80000000)\n\nMINMAXINDEX(real[, timeperiod=?])\n\nIndexes of lowest and highest values over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n minidx\n maxidx"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_259MINMAXINDEX = {"MINMAXINDEX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_259MINMAXINDEX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_258MINMAXINDEX}; static PyObject *__pyx_pw_5talib_7_ta_lib_259MINMAXINDEX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -32632,7 +31928,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4003, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4003, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -32647,7 +31943,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MINMAXINDEX", 0) < 0) __PYX_ERR(4, 4003, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MINMAXINDEX", 0) < (0)) __PYX_ERR(4, 4003, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MINMAXINDEX", 0, 1, 2, i); __PYX_ERR(4, 4003, __pyx_L3_error) } } @@ -32814,7 +32110,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_260MINUS_DI, "MINUS_DI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\nMINUS_DI(high, low, close[, timeperiod=?])\n\nMinus Directional Indicator (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_260MINUS_DI, "MINUS_DI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nMINUS_DI(high, low, close[, timeperiod=?])\n\nMinus Directional Indicator (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_261MINUS_DI = {"MINUS_DI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_261MINUS_DI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_260MINUS_DI}; static PyObject *__pyx_pw_5talib_7_ta_lib_261MINUS_DI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -32849,7 +32145,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4043, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4043, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -32872,7 +32168,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MINUS_DI", 0) < 0) __PYX_ERR(4, 4043, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MINUS_DI", 0) < (0)) __PYX_ERR(4, 4043, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MINUS_DI", 0, 3, 4, i); __PYX_ERR(4, 4043, __pyx_L3_error) } } @@ -32974,7 +32270,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_260MINUS_DI(CYTHON_UNUSED PyObject *__ __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4067, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 4067, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4068, __pyx_L1_error) @@ -33025,7 +32321,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_262MINUS_DM, "MINUS_DM(ndarray high, ndarray low, int timeperiod=-0x80000000)\nMINUS_DM(high, low[, timeperiod=?])\n\nMinus Directional Movement (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_262MINUS_DM, "MINUS_DM(ndarray high, ndarray low, int timeperiod=-0x80000000)\n\nMINUS_DM(high, low[, timeperiod=?])\n\nMinus Directional Movement (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_263MINUS_DM = {"MINUS_DM", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_263MINUS_DM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_262MINUS_DM}; static PyObject *__pyx_pw_5talib_7_ta_lib_263MINUS_DM(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -33059,7 +32355,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4076, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4076, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -33078,7 +32374,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MINUS_DM", 0) < 0) __PYX_ERR(4, 4076, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MINUS_DM", 0) < (0)) __PYX_ERR(4, 4076, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MINUS_DM", 0, 2, 3, i); __PYX_ERR(4, 4076, __pyx_L3_error) } } @@ -33170,7 +32466,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_262MINUS_DM(CYTHON_UNUSED PyObject *__ __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4099, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 4099, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4100, __pyx_L1_error) @@ -33220,7 +32516,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_264MOM, "MOM(ndarray real, int timeperiod=-0x80000000)\nMOM(real[, timeperiod=?])\n\nMomentum (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 10\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_264MOM, "MOM(ndarray real, int timeperiod=-0x80000000)\n\nMOM(real[, timeperiod=?])\n\nMomentum (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 10\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_265MOM = {"MOM", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_265MOM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_264MOM}; static PyObject *__pyx_pw_5talib_7_ta_lib_265MOM(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -33253,7 +32549,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4108, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4108, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -33268,7 +32564,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MOM", 0) < 0) __PYX_ERR(4, 4108, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MOM", 0) < (0)) __PYX_ERR(4, 4108, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MOM", 0, 1, 2, i); __PYX_ERR(4, 4108, __pyx_L3_error) } } @@ -33397,7 +32693,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_266MULT, "MULT(ndarray real0, ndarray real1)\nMULT(real0, real1)\n\nVector Arithmetic Mult (Math Operators)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_266MULT, "MULT(ndarray real0, ndarray real1)\n\nMULT(real0, real1)\n\nVector Arithmetic Mult (Math Operators)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_267MULT = {"MULT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_267MULT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_266MULT}; static PyObject *__pyx_pw_5talib_7_ta_lib_267MULT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -33430,7 +32726,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4139, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4139, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -33445,7 +32741,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MULT", 0) < 0) __PYX_ERR(4, 4139, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MULT", 0) < (0)) __PYX_ERR(4, 4139, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MULT", 1, 2, 2, i); __PYX_ERR(4, 4139, __pyx_L3_error) } } @@ -33525,7 +32821,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_266MULT(CYTHON_UNUSED PyObject *__pyx_ __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4161, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 4161, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4162, __pyx_L1_error) @@ -33575,7 +32871,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_268NATR, "NATR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\nNATR(high, low, close[, timeperiod=?])\n\nNormalized Average True Range (Volatility Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_268NATR, "NATR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nNATR(high, low, close[, timeperiod=?])\n\nNormalized Average True Range (Volatility Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_269NATR = {"NATR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_269NATR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_268NATR}; static PyObject *__pyx_pw_5talib_7_ta_lib_269NATR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -33610,7 +32906,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4170, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4170, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -33633,7 +32929,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "NATR", 0) < 0) __PYX_ERR(4, 4170, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "NATR", 0) < (0)) __PYX_ERR(4, 4170, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("NATR", 0, 3, 4, i); __PYX_ERR(4, 4170, __pyx_L3_error) } } @@ -33735,7 +33031,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_268NATR(CYTHON_UNUSED PyObject *__pyx_ __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4194, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 4194, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4195, __pyx_L1_error) @@ -33786,7 +33082,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_270OBV, "OBV(ndarray real, ndarray volume)\nOBV(real, volume)\n\nOn Balance Volume (Volume Indicators)\n\nInputs:\n real: (any ndarray)\n prices: ['volume']\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_270OBV, "OBV(ndarray real, ndarray volume)\n\nOBV(real, volume)\n\nOn Balance Volume (Volume Indicators)\n\nInputs:\n real: (any ndarray)\n prices: ['volume']\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_271OBV = {"OBV", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_271OBV, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_270OBV}; static PyObject *__pyx_pw_5talib_7_ta_lib_271OBV(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -33819,7 +33115,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_volume,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4203, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4203, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -33834,7 +33130,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "OBV", 0) < 0) __PYX_ERR(4, 4203, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "OBV", 0) < (0)) __PYX_ERR(4, 4203, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("OBV", 1, 2, 2, i); __PYX_ERR(4, 4203, __pyx_L3_error) } } @@ -33914,7 +33210,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_270OBV(CYTHON_UNUSED PyObject *__pyx_s __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4225, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 4225, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4226, __pyx_L1_error) @@ -33964,7 +33260,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_272PLUS_DI, "PLUS_DI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\nPLUS_DI(high, low, close[, timeperiod=?])\n\nPlus Directional Indicator (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_272PLUS_DI, "PLUS_DI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nPLUS_DI(high, low, close[, timeperiod=?])\n\nPlus Directional Indicator (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_273PLUS_DI = {"PLUS_DI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_273PLUS_DI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_272PLUS_DI}; static PyObject *__pyx_pw_5talib_7_ta_lib_273PLUS_DI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -33999,7 +33295,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4234, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4234, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -34022,7 +33318,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "PLUS_DI", 0) < 0) __PYX_ERR(4, 4234, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "PLUS_DI", 0) < (0)) __PYX_ERR(4, 4234, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("PLUS_DI", 0, 3, 4, i); __PYX_ERR(4, 4234, __pyx_L3_error) } } @@ -34124,7 +33420,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_272PLUS_DI(CYTHON_UNUSED PyObject *__p __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4258, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 4258, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4259, __pyx_L1_error) @@ -34175,7 +33471,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_274PLUS_DM, "PLUS_DM(ndarray high, ndarray low, int timeperiod=-0x80000000)\nPLUS_DM(high, low[, timeperiod=?])\n\nPlus Directional Movement (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_274PLUS_DM, "PLUS_DM(ndarray high, ndarray low, int timeperiod=-0x80000000)\n\nPLUS_DM(high, low[, timeperiod=?])\n\nPlus Directional Movement (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_275PLUS_DM = {"PLUS_DM", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_275PLUS_DM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_274PLUS_DM}; static PyObject *__pyx_pw_5talib_7_ta_lib_275PLUS_DM(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -34209,7 +33505,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4267, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4267, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -34228,7 +33524,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "PLUS_DM", 0) < 0) __PYX_ERR(4, 4267, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "PLUS_DM", 0) < (0)) __PYX_ERR(4, 4267, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("PLUS_DM", 0, 2, 3, i); __PYX_ERR(4, 4267, __pyx_L3_error) } } @@ -34320,7 +33616,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_274PLUS_DM(CYTHON_UNUSED PyObject *__p __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4290, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 4290, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4291, __pyx_L1_error) @@ -34370,7 +33666,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_276PPO, "PPO(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int matype=0)\nPPO(real[, fastperiod=?, slowperiod=?, matype=?])\n\nPercentage Price Oscillator (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n fastperiod: 12\n slowperiod: 26\n matype: 0 (Simple Moving Average)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_276PPO, "PPO(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int matype=0)\n\nPPO(real[, fastperiod=?, slowperiod=?, matype=?])\n\nPercentage Price Oscillator (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n fastperiod: 12\n slowperiod: 26\n matype: 0 (Simple Moving Average)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_277PPO = {"PPO", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_277PPO, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_276PPO}; static PyObject *__pyx_pw_5talib_7_ta_lib_277PPO(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -34405,7 +33701,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_fastperiod,&__pyx_mstate_global->__pyx_n_u_slowperiod,&__pyx_mstate_global->__pyx_n_u_matype,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4299, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4299, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -34428,7 +33724,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "PPO", 0) < 0) __PYX_ERR(4, 4299, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "PPO", 0) < (0)) __PYX_ERR(4, 4299, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("PPO", 0, 1, 4, i); __PYX_ERR(4, 4299, __pyx_L3_error) } } @@ -34575,7 +33871,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_278ROC, "ROC(ndarray real, int timeperiod=-0x80000000)\nROC(real[, timeperiod=?])\n\nRate of change : ((real/prevPrice)-1)*100 (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 10\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_278ROC, "ROC(ndarray real, int timeperiod=-0x80000000)\n\nROC(real[, timeperiod=?])\n\nRate of change : ((real/prevPrice)-1)*100 (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 10\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_279ROC = {"ROC", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_279ROC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_278ROC}; static PyObject *__pyx_pw_5talib_7_ta_lib_279ROC(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -34608,7 +33904,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4332, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4332, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -34623,7 +33919,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ROC", 0) < 0) __PYX_ERR(4, 4332, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ROC", 0) < (0)) __PYX_ERR(4, 4332, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ROC", 0, 1, 2, i); __PYX_ERR(4, 4332, __pyx_L3_error) } } @@ -34752,7 +34048,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_280ROCP, "ROCP(ndarray real, int timeperiod=-0x80000000)\nROCP(real[, timeperiod=?])\n\nRate of change Percentage: (real-prevPrice)/prevPrice (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 10\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_280ROCP, "ROCP(ndarray real, int timeperiod=-0x80000000)\n\nROCP(real[, timeperiod=?])\n\nRate of change Percentage: (real-prevPrice)/prevPrice (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 10\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_281ROCP = {"ROCP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_281ROCP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_280ROCP}; static PyObject *__pyx_pw_5talib_7_ta_lib_281ROCP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -34785,7 +34081,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4363, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4363, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -34800,7 +34096,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ROCP", 0) < 0) __PYX_ERR(4, 4363, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ROCP", 0) < (0)) __PYX_ERR(4, 4363, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ROCP", 0, 1, 2, i); __PYX_ERR(4, 4363, __pyx_L3_error) } } @@ -34929,7 +34225,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_282ROCR, "ROCR(ndarray real, int timeperiod=-0x80000000)\nROCR(real[, timeperiod=?])\n\nRate of change ratio: (real/prevPrice) (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 10\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_282ROCR, "ROCR(ndarray real, int timeperiod=-0x80000000)\n\nROCR(real[, timeperiod=?])\n\nRate of change ratio: (real/prevPrice) (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 10\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_283ROCR = {"ROCR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_283ROCR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_282ROCR}; static PyObject *__pyx_pw_5talib_7_ta_lib_283ROCR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -34962,7 +34258,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4394, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4394, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -34977,7 +34273,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ROCR", 0) < 0) __PYX_ERR(4, 4394, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ROCR", 0) < (0)) __PYX_ERR(4, 4394, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ROCR", 0, 1, 2, i); __PYX_ERR(4, 4394, __pyx_L3_error) } } @@ -35106,7 +34402,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_284ROCR100, "ROCR100(ndarray real, int timeperiod=-0x80000000)\nROCR100(real[, timeperiod=?])\n\nRate of change ratio 100 scale: (real/prevPrice)*100 (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 10\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_284ROCR100, "ROCR100(ndarray real, int timeperiod=-0x80000000)\n\nROCR100(real[, timeperiod=?])\n\nRate of change ratio 100 scale: (real/prevPrice)*100 (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 10\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_285ROCR100 = {"ROCR100", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_285ROCR100, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_284ROCR100}; static PyObject *__pyx_pw_5talib_7_ta_lib_285ROCR100(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -35139,7 +34435,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4425, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4425, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -35154,7 +34450,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ROCR100", 0) < 0) __PYX_ERR(4, 4425, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ROCR100", 0) < (0)) __PYX_ERR(4, 4425, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ROCR100", 0, 1, 2, i); __PYX_ERR(4, 4425, __pyx_L3_error) } } @@ -35283,7 +34579,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_286RSI, "RSI(ndarray real, int timeperiod=-0x80000000)\nRSI(real[, timeperiod=?])\n\nRelative Strength Index (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_286RSI, "RSI(ndarray real, int timeperiod=-0x80000000)\n\nRSI(real[, timeperiod=?])\n\nRelative Strength Index (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_287RSI = {"RSI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_287RSI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_286RSI}; static PyObject *__pyx_pw_5talib_7_ta_lib_287RSI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -35316,7 +34612,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4456, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4456, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -35331,7 +34627,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "RSI", 0) < 0) __PYX_ERR(4, 4456, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "RSI", 0) < (0)) __PYX_ERR(4, 4456, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("RSI", 0, 1, 2, i); __PYX_ERR(4, 4456, __pyx_L3_error) } } @@ -35460,7 +34756,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_288SAR, "SAR(ndarray high, ndarray low, double acceleration=0.02, double maximum=0.2)\nSAR(high, low[, acceleration=?, maximum=?])\n\nParabolic SAR (Overlap Studies)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n acceleration: 0.02\n maximum: 0.2\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_288SAR, "SAR(ndarray high, ndarray low, double acceleration=0.02, double maximum=0.2)\n\nSAR(high, low[, acceleration=?, maximum=?])\n\nParabolic SAR (Overlap Studies)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n acceleration: 0.02\n maximum: 0.2\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_289SAR = {"SAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_289SAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_288SAR}; static PyObject *__pyx_pw_5talib_7_ta_lib_289SAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -35495,7 +34791,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_acceleration,&__pyx_mstate_global->__pyx_n_u_maximum,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4487, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4487, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -35518,7 +34814,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SAR", 0) < 0) __PYX_ERR(4, 4487, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SAR", 0) < (0)) __PYX_ERR(4, 4487, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("SAR", 0, 2, 4, i); __PYX_ERR(4, 4487, __pyx_L3_error) } } @@ -35619,7 +34915,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_288SAR(CYTHON_UNUSED PyObject *__pyx_s __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4511, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 4511, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4512, __pyx_L1_error) @@ -35669,7 +34965,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_290SAREXT, "SAREXT(ndarray high, ndarray low, double startvalue=-4e37, double offsetonreverse=-4e37, double accelerationinitlong=-4e37, double accelerationlong=-4e37, double accelerationmaxlong=-4e37, double accelerationinitshort=-4e37, double accelerationshort=-4e37, double accelerationmaxshort=-4e37)\nSAREXT(high, low[, startvalue=?, offsetonreverse=?, accelerationinitlong=?, accelerationlong=?, accelerationmaxlong=?, accelerationinitshort=?, accelerationshort=?, accelerationmaxshort=?])\n\nParabolic SAR - Extended (Overlap Studies)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n startvalue: 0.0\n offsetonreverse: 0.0\n accelerationinitlong: 0.02\n accelerationlong: 0.02\n accelerationmaxlong: 0.2\n accelerationinitshort: 0.02\n accelerationshort: 0.02\n accelerationmaxshort: 0.2\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_290SAREXT, "SAREXT(ndarray high, ndarray low, double startvalue=-4e37, double offsetonreverse=-4e37, double accelerationinitlong=-4e37, double accelerationlong=-4e37, double accelerationmaxlong=-4e37, double accelerationinitshort=-4e37, double accelerationshort=-4e37, double accelerationmaxshort=-4e37)\n\nSAREXT(high, low[, startvalue=?, offsetonreverse=?, accelerationinitlong=?, accelerationlong=?, accelerationmaxlong=?, accelerationinitshort=?, accelerationshort=?, accelerationmaxshort=?])\n\nParabolic SAR - Extended (Overlap Studies)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n startvalue: 0.0\n offsetonreverse: 0.0\n accelerationinitlong: 0.02\n accelerationlong: 0.02\n accelerationmaxlong: 0.2\n accelerationinitshort: 0.02\n accelerationshort: 0.02\n accelerationmaxshort: 0.2\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_291SAREXT = {"SAREXT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_291SAREXT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_290SAREXT}; static PyObject *__pyx_pw_5talib_7_ta_lib_291SAREXT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -35710,7 +35006,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_startvalue,&__pyx_mstate_global->__pyx_n_u_offsetonreverse,&__pyx_mstate_global->__pyx_n_u_accelerationinitlong,&__pyx_mstate_global->__pyx_n_u_accelerationlong,&__pyx_mstate_global->__pyx_n_u_accelerationmaxlong,&__pyx_mstate_global->__pyx_n_u_accelerationinitshort,&__pyx_mstate_global->__pyx_n_u_accelerationshort,&__pyx_mstate_global->__pyx_n_u_accelerationmaxshort,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4520, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4520, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 10: @@ -35757,7 +35053,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SAREXT", 0) < 0) __PYX_ERR(4, 4520, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SAREXT", 0) < (0)) __PYX_ERR(4, 4520, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("SAREXT", 0, 2, 10, i); __PYX_ERR(4, 4520, __pyx_L3_error) } } @@ -35912,7 +35208,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_290SAREXT(CYTHON_UNUSED PyObject *__py __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4550, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 4550, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4551, __pyx_L1_error) @@ -35962,7 +35258,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_292SIN, "SIN(ndarray real)\nSIN(real)\n\nVector Trigonometric Sin (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_292SIN, "SIN(ndarray real)\n\nSIN(real)\n\nVector Trigonometric Sin (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_293SIN = {"SIN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_293SIN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_292SIN}; static PyObject *__pyx_pw_5talib_7_ta_lib_293SIN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -35994,7 +35290,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4559, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4559, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -36005,7 +35301,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SIN", 0) < 0) __PYX_ERR(4, 4559, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SIN", 0) < (0)) __PYX_ERR(4, 4559, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("SIN", 1, 1, 1, i); __PYX_ERR(4, 4559, __pyx_L3_error) } } @@ -36122,7 +35418,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_294SINH, "SINH(ndarray real)\nSINH(real)\n\nVector Trigonometric Sinh (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_294SINH, "SINH(ndarray real)\n\nSINH(real)\n\nVector Trigonometric Sinh (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_295SINH = {"SINH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_295SINH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_294SINH}; static PyObject *__pyx_pw_5talib_7_ta_lib_295SINH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -36154,7 +35450,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4588, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4588, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -36165,7 +35461,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SINH", 0) < 0) __PYX_ERR(4, 4588, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SINH", 0) < (0)) __PYX_ERR(4, 4588, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("SINH", 1, 1, 1, i); __PYX_ERR(4, 4588, __pyx_L3_error) } } @@ -36282,7 +35578,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_296SMA, "SMA(ndarray real, int timeperiod=-0x80000000)\nSMA(real[, timeperiod=?])\n\nSimple Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_296SMA, "SMA(ndarray real, int timeperiod=-0x80000000)\n\nSMA(real[, timeperiod=?])\n\nSimple Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_297SMA = {"SMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_297SMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_296SMA}; static PyObject *__pyx_pw_5talib_7_ta_lib_297SMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -36315,7 +35611,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4617, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4617, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -36330,7 +35626,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SMA", 0) < 0) __PYX_ERR(4, 4617, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SMA", 0) < (0)) __PYX_ERR(4, 4617, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("SMA", 0, 1, 2, i); __PYX_ERR(4, 4617, __pyx_L3_error) } } @@ -36459,7 +35755,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_298SQRT, "SQRT(ndarray real)\nSQRT(real)\n\nVector Square Root (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_298SQRT, "SQRT(ndarray real)\n\nSQRT(real)\n\nVector Square Root (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_299SQRT = {"SQRT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_299SQRT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_298SQRT}; static PyObject *__pyx_pw_5talib_7_ta_lib_299SQRT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -36491,7 +35787,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4648, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4648, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -36502,7 +35798,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SQRT", 0) < 0) __PYX_ERR(4, 4648, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SQRT", 0) < (0)) __PYX_ERR(4, 4648, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("SQRT", 1, 1, 1, i); __PYX_ERR(4, 4648, __pyx_L3_error) } } @@ -36619,7 +35915,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_300STDDEV, "STDDEV(ndarray real, int timeperiod=-0x80000000, double nbdev=-4e37)\nSTDDEV(real[, timeperiod=?, nbdev=?])\n\nStandard Deviation (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 5\n nbdev: 1.0\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_300STDDEV, "STDDEV(ndarray real, int timeperiod=-0x80000000, double nbdev=-4e37)\n\nSTDDEV(real[, timeperiod=?, nbdev=?])\n\nStandard Deviation (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 5\n nbdev: 1.0\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_301STDDEV = {"STDDEV", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_301STDDEV, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_300STDDEV}; static PyObject *__pyx_pw_5talib_7_ta_lib_301STDDEV(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -36653,7 +35949,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_nbdev,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4677, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4677, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -36672,7 +35968,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "STDDEV", 0) < 0) __PYX_ERR(4, 4677, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "STDDEV", 0) < (0)) __PYX_ERR(4, 4677, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("STDDEV", 0, 1, 3, i); __PYX_ERR(4, 4677, __pyx_L3_error) } } @@ -36810,7 +36106,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_302STOCH, "STOCH(ndarray high, ndarray low, ndarray close, int fastk_period=-0x80000000, int slowk_period=-0x80000000, int slowk_matype=0, int slowd_period=-0x80000000, int slowd_matype=0)\nSTOCH(high, low, close[, fastk_period=?, slowk_period=?, slowk_matype=?, slowd_period=?, slowd_matype=?])\n\nStochastic (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n fastk_period: 5\n slowk_period: 3\n slowk_matype: 0\n slowd_period: 3\n slowd_matype: 0\nOutputs:\n slowk\n slowd"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_302STOCH, "STOCH(ndarray high, ndarray low, ndarray close, int fastk_period=-0x80000000, int slowk_period=-0x80000000, int slowk_matype=0, int slowd_period=-0x80000000, int slowd_matype=0)\n\nSTOCH(high, low, close[, fastk_period=?, slowk_period=?, slowk_matype=?, slowd_period=?, slowd_matype=?])\n\nStochastic (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n fastk_period: 5\n slowk_period: 3\n slowk_matype: 0\n slowd_period: 3\n slowd_matype: 0\nOutputs:\n slowk\n slowd"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_303STOCH = {"STOCH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_303STOCH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_302STOCH}; static PyObject *__pyx_pw_5talib_7_ta_lib_303STOCH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -36849,7 +36145,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_fastk_period,&__pyx_mstate_global->__pyx_n_u_slowk_period,&__pyx_mstate_global->__pyx_n_u_slowk_matype,&__pyx_mstate_global->__pyx_n_u_slowd_period,&__pyx_mstate_global->__pyx_n_u_slowd_matype,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4709, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4709, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 8: @@ -36888,7 +36184,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "STOCH", 0) < 0) __PYX_ERR(4, 4709, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "STOCH", 0) < (0)) __PYX_ERR(4, 4709, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("STOCH", 0, 3, 8, i); __PYX_ERR(4, 4709, __pyx_L3_error) } } @@ -37027,7 +36323,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_302STOCH(CYTHON_UNUSED PyObject *__pyx __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4739, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 4739, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4740, __pyx_L1_error) @@ -37092,7 +36388,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_304STOCHF, "STOCHF(ndarray high, ndarray low, ndarray close, int fastk_period=-0x80000000, int fastd_period=-0x80000000, int fastd_matype=0)\nSTOCHF(high, low, close[, fastk_period=?, fastd_period=?, fastd_matype=?])\n\nStochastic Fast (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n fastk_period: 5\n fastd_period: 3\n fastd_matype: 0\nOutputs:\n fastk\n fastd"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_304STOCHF, "STOCHF(ndarray high, ndarray low, ndarray close, int fastk_period=-0x80000000, int fastd_period=-0x80000000, int fastd_matype=0)\n\nSTOCHF(high, low, close[, fastk_period=?, fastd_period=?, fastd_matype=?])\n\nStochastic Fast (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n fastk_period: 5\n fastd_period: 3\n fastd_matype: 0\nOutputs:\n fastk\n fastd"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_305STOCHF = {"STOCHF", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_305STOCHF, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_304STOCHF}; static PyObject *__pyx_pw_5talib_7_ta_lib_305STOCHF(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -37129,7 +36425,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_fastk_period,&__pyx_mstate_global->__pyx_n_u_fastd_period,&__pyx_mstate_global->__pyx_n_u_fastd_matype,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4749, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4749, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 6: @@ -37160,7 +36456,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "STOCHF", 0) < 0) __PYX_ERR(4, 4749, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "STOCHF", 0) < (0)) __PYX_ERR(4, 4749, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("STOCHF", 0, 3, 6, i); __PYX_ERR(4, 4749, __pyx_L3_error) } } @@ -37281,7 +36577,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_304STOCHF(CYTHON_UNUSED PyObject *__py __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4777, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 4777, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4778, __pyx_L1_error) @@ -37346,7 +36642,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_306STOCHRSI, "STOCHRSI(ndarray real, int timeperiod=-0x80000000, int fastk_period=-0x80000000, int fastd_period=-0x80000000, int fastd_matype=0)\nSTOCHRSI(real[, timeperiod=?, fastk_period=?, fastd_period=?, fastd_matype=?])\n\nStochastic Relative Strength Index (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\n fastk_period: 5\n fastd_period: 3\n fastd_matype: 0\nOutputs:\n fastk\n fastd"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_306STOCHRSI, "STOCHRSI(ndarray real, int timeperiod=-0x80000000, int fastk_period=-0x80000000, int fastd_period=-0x80000000, int fastd_matype=0)\n\nSTOCHRSI(real[, timeperiod=?, fastk_period=?, fastd_period=?, fastd_matype=?])\n\nStochastic Relative Strength Index (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\n fastk_period: 5\n fastd_period: 3\n fastd_matype: 0\nOutputs:\n fastk\n fastd"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_307STOCHRSI = {"STOCHRSI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_307STOCHRSI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_306STOCHRSI}; static PyObject *__pyx_pw_5talib_7_ta_lib_307STOCHRSI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -37382,7 +36678,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_fastk_period,&__pyx_mstate_global->__pyx_n_u_fastd_period,&__pyx_mstate_global->__pyx_n_u_fastd_matype,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4787, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4787, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 5: @@ -37409,7 +36705,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "STOCHRSI", 0) < 0) __PYX_ERR(4, 4787, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "STOCHRSI", 0) < (0)) __PYX_ERR(4, 4787, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("STOCHRSI", 0, 1, 5, i); __PYX_ERR(4, 4787, __pyx_L3_error) } } @@ -37580,7 +36876,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_308SUB, "SUB(ndarray real0, ndarray real1)\nSUB(real0, real1)\n\nVector Arithmetic Subtraction (Math Operators)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_308SUB, "SUB(ndarray real0, ndarray real1)\n\nSUB(real0, real1)\n\nVector Arithmetic Subtraction (Math Operators)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_309SUB = {"SUB", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_309SUB, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_308SUB}; static PyObject *__pyx_pw_5talib_7_ta_lib_309SUB(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -37613,7 +36909,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4824, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4824, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -37628,7 +36924,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SUB", 0) < 0) __PYX_ERR(4, 4824, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SUB", 0) < (0)) __PYX_ERR(4, 4824, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("SUB", 1, 2, 2, i); __PYX_ERR(4, 4824, __pyx_L3_error) } } @@ -37708,7 +37004,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_308SUB(CYTHON_UNUSED PyObject *__pyx_s __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4846, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 4846, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4847, __pyx_L1_error) @@ -37758,7 +37054,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_310SUM, "SUM(ndarray real, int timeperiod=-0x80000000)\nSUM(real[, timeperiod=?])\n\nSummation (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_310SUM, "SUM(ndarray real, int timeperiod=-0x80000000)\n\nSUM(real[, timeperiod=?])\n\nSummation (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_311SUM = {"SUM", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_311SUM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_310SUM}; static PyObject *__pyx_pw_5talib_7_ta_lib_311SUM(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -37791,7 +37087,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4855, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4855, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -37806,7 +37102,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SUM", 0) < 0) __PYX_ERR(4, 4855, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SUM", 0) < (0)) __PYX_ERR(4, 4855, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("SUM", 0, 1, 2, i); __PYX_ERR(4, 4855, __pyx_L3_error) } } @@ -37935,7 +37231,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_312T3, "T3(ndarray real, int timeperiod=-0x80000000, double vfactor=-4e37)\nT3(real[, timeperiod=?, vfactor=?])\n\nTriple Exponential Moving Average (T3) (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 5\n vfactor: 0.7\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_312T3, "T3(ndarray real, int timeperiod=-0x80000000, double vfactor=-4e37)\n\nT3(real[, timeperiod=?, vfactor=?])\n\nTriple Exponential Moving Average (T3) (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 5\n vfactor: 0.7\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_313T3 = {"T3", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_313T3, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_312T3}; static PyObject *__pyx_pw_5talib_7_ta_lib_313T3(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -37969,7 +37265,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_vfactor,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4886, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4886, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -37988,7 +37284,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "T3", 0) < 0) __PYX_ERR(4, 4886, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "T3", 0) < (0)) __PYX_ERR(4, 4886, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("T3", 0, 1, 3, i); __PYX_ERR(4, 4886, __pyx_L3_error) } } @@ -38126,7 +37422,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_314TAN, "TAN(ndarray real)\nTAN(real)\n\nVector Trigonometric Tan (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_314TAN, "TAN(ndarray real)\n\nTAN(real)\n\nVector Trigonometric Tan (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_315TAN = {"TAN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_315TAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_314TAN}; static PyObject *__pyx_pw_5talib_7_ta_lib_315TAN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -38158,7 +37454,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4918, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4918, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -38169,7 +37465,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TAN", 0) < 0) __PYX_ERR(4, 4918, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TAN", 0) < (0)) __PYX_ERR(4, 4918, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("TAN", 1, 1, 1, i); __PYX_ERR(4, 4918, __pyx_L3_error) } } @@ -38286,7 +37582,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_316TANH, "TANH(ndarray real)\nTANH(real)\n\nVector Trigonometric Tanh (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_316TANH, "TANH(ndarray real)\n\nTANH(real)\n\nVector Trigonometric Tanh (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_317TANH = {"TANH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_317TANH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_316TANH}; static PyObject *__pyx_pw_5talib_7_ta_lib_317TANH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -38318,7 +37614,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4947, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4947, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -38329,7 +37625,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TANH", 0) < 0) __PYX_ERR(4, 4947, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TANH", 0) < (0)) __PYX_ERR(4, 4947, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("TANH", 1, 1, 1, i); __PYX_ERR(4, 4947, __pyx_L3_error) } } @@ -38446,7 +37742,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_318TEMA, "TEMA(ndarray real, int timeperiod=-0x80000000)\nTEMA(real[, timeperiod=?])\n\nTriple Exponential Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_318TEMA, "TEMA(ndarray real, int timeperiod=-0x80000000)\n\nTEMA(real[, timeperiod=?])\n\nTriple Exponential Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_319TEMA = {"TEMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_319TEMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_318TEMA}; static PyObject *__pyx_pw_5talib_7_ta_lib_319TEMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -38479,7 +37775,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4976, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 4976, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -38494,7 +37790,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TEMA", 0) < 0) __PYX_ERR(4, 4976, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TEMA", 0) < (0)) __PYX_ERR(4, 4976, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("TEMA", 0, 1, 2, i); __PYX_ERR(4, 4976, __pyx_L3_error) } } @@ -38623,7 +37919,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_320TRANGE, "TRANGE(ndarray high, ndarray low, ndarray close)\nTRANGE(high, low, close)\n\nTrue Range (Volatility Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_320TRANGE, "TRANGE(ndarray high, ndarray low, ndarray close)\n\nTRANGE(high, low, close)\n\nTrue Range (Volatility Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_321TRANGE = {"TRANGE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_321TRANGE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_320TRANGE}; static PyObject *__pyx_pw_5talib_7_ta_lib_321TRANGE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -38657,7 +37953,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 5007, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 5007, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -38676,7 +37972,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TRANGE", 0) < 0) __PYX_ERR(4, 5007, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TRANGE", 0) < (0)) __PYX_ERR(4, 5007, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("TRANGE", 1, 3, 3, i); __PYX_ERR(4, 5007, __pyx_L3_error) } } @@ -38766,7 +38062,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_320TRANGE(CYTHON_UNUSED PyObject *__py __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 5029, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 5029, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5030, __pyx_L1_error) @@ -38817,7 +38113,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_322TRIMA, "TRIMA(ndarray real, int timeperiod=-0x80000000)\nTRIMA(real[, timeperiod=?])\n\nTriangular Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_322TRIMA, "TRIMA(ndarray real, int timeperiod=-0x80000000)\n\nTRIMA(real[, timeperiod=?])\n\nTriangular Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_323TRIMA = {"TRIMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_323TRIMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_322TRIMA}; static PyObject *__pyx_pw_5talib_7_ta_lib_323TRIMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -38850,7 +38146,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 5038, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 5038, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -38865,7 +38161,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TRIMA", 0) < 0) __PYX_ERR(4, 5038, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TRIMA", 0) < (0)) __PYX_ERR(4, 5038, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("TRIMA", 0, 1, 2, i); __PYX_ERR(4, 5038, __pyx_L3_error) } } @@ -38994,7 +38290,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_324TRIX, "TRIX(ndarray real, int timeperiod=-0x80000000)\nTRIX(real[, timeperiod=?])\n\n1-day Rate-Of-Change (ROC) of a Triple Smooth EMA (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_324TRIX, "TRIX(ndarray real, int timeperiod=-0x80000000)\n\nTRIX(real[, timeperiod=?])\n\n1-day Rate-Of-Change (ROC) of a Triple Smooth EMA (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_325TRIX = {"TRIX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_325TRIX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_324TRIX}; static PyObject *__pyx_pw_5talib_7_ta_lib_325TRIX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -39027,7 +38323,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 5069, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 5069, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -39042,7 +38338,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TRIX", 0) < 0) __PYX_ERR(4, 5069, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TRIX", 0) < (0)) __PYX_ERR(4, 5069, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("TRIX", 0, 1, 2, i); __PYX_ERR(4, 5069, __pyx_L3_error) } } @@ -39171,7 +38467,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_326TSF, "TSF(ndarray real, int timeperiod=-0x80000000)\nTSF(real[, timeperiod=?])\n\nTime Series Forecast (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_326TSF, "TSF(ndarray real, int timeperiod=-0x80000000)\n\nTSF(real[, timeperiod=?])\n\nTime Series Forecast (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_327TSF = {"TSF", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_327TSF, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_326TSF}; static PyObject *__pyx_pw_5talib_7_ta_lib_327TSF(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -39204,7 +38500,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 5100, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 5100, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -39219,7 +38515,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TSF", 0) < 0) __PYX_ERR(4, 5100, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TSF", 0) < (0)) __PYX_ERR(4, 5100, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("TSF", 0, 1, 2, i); __PYX_ERR(4, 5100, __pyx_L3_error) } } @@ -39348,7 +38644,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_328TYPPRICE, "TYPPRICE(ndarray high, ndarray low, ndarray close)\nTYPPRICE(high, low, close)\n\nTypical Price (Price Transform)\n\nInputs:\n prices: ['high', 'low', 'close']\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_328TYPPRICE, "TYPPRICE(ndarray high, ndarray low, ndarray close)\n\nTYPPRICE(high, low, close)\n\nTypical Price (Price Transform)\n\nInputs:\n prices: ['high', 'low', 'close']\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_329TYPPRICE = {"TYPPRICE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_329TYPPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_328TYPPRICE}; static PyObject *__pyx_pw_5talib_7_ta_lib_329TYPPRICE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -39382,7 +38678,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 5131, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 5131, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -39401,7 +38697,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TYPPRICE", 0) < 0) __PYX_ERR(4, 5131, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TYPPRICE", 0) < (0)) __PYX_ERR(4, 5131, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("TYPPRICE", 1, 3, 3, i); __PYX_ERR(4, 5131, __pyx_L3_error) } } @@ -39491,7 +38787,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_328TYPPRICE(CYTHON_UNUSED PyObject *__ __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 5153, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 5153, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5154, __pyx_L1_error) @@ -39542,7 +38838,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_330ULTOSC, "ULTOSC(ndarray high, ndarray low, ndarray close, int timeperiod1=-0x80000000, int timeperiod2=-0x80000000, int timeperiod3=-0x80000000)\nULTOSC(high, low, close[, timeperiod1=?, timeperiod2=?, timeperiod3=?])\n\nUltimate Oscillator (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod1: 7\n timeperiod2: 14\n timeperiod3: 28\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_330ULTOSC, "ULTOSC(ndarray high, ndarray low, ndarray close, int timeperiod1=-0x80000000, int timeperiod2=-0x80000000, int timeperiod3=-0x80000000)\n\nULTOSC(high, low, close[, timeperiod1=?, timeperiod2=?, timeperiod3=?])\n\nUltimate Oscillator (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod1: 7\n timeperiod2: 14\n timeperiod3: 28\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_331ULTOSC = {"ULTOSC", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_331ULTOSC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_330ULTOSC}; static PyObject *__pyx_pw_5talib_7_ta_lib_331ULTOSC(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -39579,7 +38875,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod1,&__pyx_mstate_global->__pyx_n_u_timeperiod2,&__pyx_mstate_global->__pyx_n_u_timeperiod3,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 5162, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 5162, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 6: @@ -39610,7 +38906,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ULTOSC", 0) < 0) __PYX_ERR(4, 5162, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ULTOSC", 0) < (0)) __PYX_ERR(4, 5162, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ULTOSC", 0, 3, 6, i); __PYX_ERR(4, 5162, __pyx_L3_error) } } @@ -39730,7 +39026,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_330ULTOSC(CYTHON_UNUSED PyObject *__py __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 5188, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 5188, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5189, __pyx_L1_error) @@ -39781,7 +39077,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_332VAR, "VAR(ndarray real, int timeperiod=-0x80000000, double nbdev=-4e37)\nVAR(real[, timeperiod=?, nbdev=?])\n\nVariance (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 5\n nbdev: 1.0\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_332VAR, "VAR(ndarray real, int timeperiod=-0x80000000, double nbdev=-4e37)\n\nVAR(real[, timeperiod=?, nbdev=?])\n\nVariance (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 5\n nbdev: 1.0\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_333VAR = {"VAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_333VAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_332VAR}; static PyObject *__pyx_pw_5talib_7_ta_lib_333VAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -39815,7 +39111,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_nbdev,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 5197, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 5197, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -39834,7 +39130,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "VAR", 0) < 0) __PYX_ERR(4, 5197, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "VAR", 0) < (0)) __PYX_ERR(4, 5197, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("VAR", 0, 1, 3, i); __PYX_ERR(4, 5197, __pyx_L3_error) } } @@ -39972,7 +39268,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_334WCLPRICE, "WCLPRICE(ndarray high, ndarray low, ndarray close)\nWCLPRICE(high, low, close)\n\nWeighted Close Price (Price Transform)\n\nInputs:\n prices: ['high', 'low', 'close']\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_334WCLPRICE, "WCLPRICE(ndarray high, ndarray low, ndarray close)\n\nWCLPRICE(high, low, close)\n\nWeighted Close Price (Price Transform)\n\nInputs:\n prices: ['high', 'low', 'close']\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_335WCLPRICE = {"WCLPRICE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_335WCLPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_334WCLPRICE}; static PyObject *__pyx_pw_5talib_7_ta_lib_335WCLPRICE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -40006,7 +39302,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 5229, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 5229, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -40025,7 +39321,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "WCLPRICE", 0) < 0) __PYX_ERR(4, 5229, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "WCLPRICE", 0) < (0)) __PYX_ERR(4, 5229, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("WCLPRICE", 1, 3, 3, i); __PYX_ERR(4, 5229, __pyx_L3_error) } } @@ -40115,7 +39411,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_334WCLPRICE(CYTHON_UNUSED PyObject *__ __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 5251, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 5251, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5252, __pyx_L1_error) @@ -40166,7 +39462,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_336WILLR, "WILLR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\nWILLR(high, low, close[, timeperiod=?])\n\nWilliams' %R (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_336WILLR, "WILLR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nWILLR(high, low, close[, timeperiod=?])\n\nWilliams' %R (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_337WILLR = {"WILLR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_337WILLR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_336WILLR}; static PyObject *__pyx_pw_5talib_7_ta_lib_337WILLR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -40201,7 +39497,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 5260, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 5260, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -40224,7 +39520,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "WILLR", 0) < 0) __PYX_ERR(4, 5260, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "WILLR", 0) < (0)) __PYX_ERR(4, 5260, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("WILLR", 0, 3, 4, i); __PYX_ERR(4, 5260, __pyx_L3_error) } } @@ -40326,7 +39622,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_336WILLR(CYTHON_UNUSED PyObject *__pyx __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 5284, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 5284, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5285, __pyx_L1_error) @@ -40377,7 +39673,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_338WMA, "WMA(ndarray real, int timeperiod=-0x80000000)\nWMA(real[, timeperiod=?])\n\nWeighted Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_338WMA, "WMA(ndarray real, int timeperiod=-0x80000000)\n\nWMA(real[, timeperiod=?])\n\nWeighted Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_339WMA = {"WMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_339WMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_338WMA}; static PyObject *__pyx_pw_5talib_7_ta_lib_339WMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -40410,7 +39706,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 5293, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(4, 5293, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -40425,7 +39721,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "WMA", 0) < 0) __PYX_ERR(4, 5293, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "WMA", 0) < (0)) __PYX_ERR(4, 5293, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("WMA", 0, 1, 2, i); __PYX_ERR(4, 5293, __pyx_L3_error) } } @@ -40586,7 +39882,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_s,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 74, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 74, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -40597,7 +39893,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "str2bytes", 0) < 0) __PYX_ERR(2, 74, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "str2bytes", 0) < (0)) __PYX_ERR(2, 74, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("str2bytes", 1, 1, 1, i); __PYX_ERR(2, 74, __pyx_L3_error) } } @@ -40637,8 +39933,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_340str2bytes(CYTHON_UNUSED PyObject *_ __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - size_t __pyx_t_4; + size_t __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -40646,14 +39941,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_340str2bytes(CYTHON_UNUSED PyObject *_ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = NULL; - __Pyx_INCREF((PyObject *)(&PyBytes_Type)); - __pyx_t_3 = ((PyObject *)(&PyBytes_Type)); - __pyx_t_4 = 1; + __pyx_t_3 = 1; { PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_s, __pyx_mstate_global->__pyx_n_u_ascii}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(&PyBytes_Type), __pyx_callargs+__pyx_t_3, (3-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 75, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } @@ -40666,7 +39958,6 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_340str2bytes(CYTHON_UNUSED PyObject *_ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("talib._ta_lib.str2bytes", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -40716,7 +40007,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_b,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 77, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 77, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -40727,7 +40018,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "bytes2str", 0) < 0) __PYX_ERR(2, 77, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "bytes2str", 0) < (0)) __PYX_ERR(2, 77, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("bytes2str", 1, 1, 1, i); __PYX_ERR(2, 77, __pyx_L3_error) } } @@ -40779,7 +40070,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_342bytes2str(CYTHON_UNUSED PyObject *_ __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ascii}; - __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_decode, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_decode, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 78, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -40842,7 +40133,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_s,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 82, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 82, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -40853,7 +40144,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "str2bytes", 0) < 0) __PYX_ERR(2, 82, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "str2bytes", 0) < (0)) __PYX_ERR(2, 82, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("str2bytes", 1, 1, 1, i); __PYX_ERR(2, 82, __pyx_L3_error) } } @@ -40947,7 +40238,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_b,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 85, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 85, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -40958,7 +40249,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "bytes2str", 0) < 0) __PYX_ERR(2, 85, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "bytes2str", 0) < (0)) __PYX_ERR(2, 85, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("bytes2str", 1, 1, 1, i); __PYX_ERR(2, 85, __pyx_L3_error) } } @@ -41065,7 +40356,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_function_name,&__pyx_mstate_global->__pyx_n_u_func_object,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 117, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 117, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { default: @@ -41085,7 +40376,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } const Py_ssize_t kwd_pos_args = __pyx_nargs; const Py_ssize_t used_pos_args = (kwd_pos_args < 3) ? kwd_pos_args : 3; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, __pyx_kwds_len, "__init__", 1) < 0) __PYX_ERR(2, 117, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, __pyx_kwds_len, "__init__", 1) < (0)) __PYX_ERR(2, 117, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 3, i); __PYX_ERR(2, 117, __pyx_L3_error) } } @@ -41148,17 +40439,17 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function___init__(CYTHON_UNUSED PyObj __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_upper, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_upper, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 119, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } - if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name, __pyx_t_1) < 0) __PYX_ERR(2, 119, __pyx_L1_error) + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name, __pyx_t_1) < (0)) __PYX_ERR(2, 119, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__namestr, __pyx_t_1) < 0) __PYX_ERR(2, 120, __pyx_L1_error) + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__namestr, __pyx_t_1) < (0)) __PYX_ERR(2, 120, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = NULL; @@ -41180,14 +40471,14 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function___init__(CYTHON_UNUSED PyObj #endif { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_5}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } - if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name, __pyx_t_1) < 0) __PYX_ERR(2, 121, __pyx_L1_error) + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name, __pyx_t_1) < (0)) __PYX_ERR(2, 121, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_4 = NULL; @@ -41210,13 +40501,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function___init__(CYTHON_UNUSED PyObj #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_2, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 124, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } - if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__localdata, __pyx_t_1) < 0) __PYX_ERR(2, 124, __pyx_L1_error) + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__localdata, __pyx_t_1) < (0)) __PYX_ERR(2, 124, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_set_function_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 127, __pyx_L1_error) @@ -41229,7 +40520,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function___init__(CYTHON_UNUSED PyObj __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_func_object, __pyx_v_func_object) < 0) __PYX_ERR(2, 128, __pyx_L1_error) + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_func_object, __pyx_v_func_object) < (0)) __PYX_ERR(2, 128, __pyx_L1_error) /* function exit code */ @@ -41289,7 +40580,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 130, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 130, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -41300,7 +40591,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__local", 0) < 0) __PYX_ERR(2, 130, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__local", 0) < (0)) __PYX_ERR(2, 130, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__local", 1, 1, 1, i); __PYX_ERR(2, 130, __pyx_L3_error) } } @@ -41352,9 +40643,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_2__local(CYTHON_UNUSED PyObj size_t __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; - PyObject *__pyx_t_9 = NULL; - Py_ssize_t __pyx_t_10; - PyObject *(*__pyx_t_11)(PyObject *); + PyObject *(*__pyx_t_9)(PyObject *); int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -41369,11 +40658,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_2__local(CYTHON_UNUSED PyObj __pyx_t_3 = (!__pyx_t_2); if (__pyx_t_3) { - if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info, Py_None) < 0) __PYX_ERR(2, 134, __pyx_L1_error) + if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info, Py_None) < (0)) __PYX_ERR(2, 134, __pyx_L1_error) __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays, __pyx_t_1) < 0) __PYX_ERR(2, 135, __pyx_L1_error) + if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays, __pyx_t_1) < (0)) __PYX_ERR(2, 135, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_4 = NULL; @@ -41393,13 +40682,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_2__local(CYTHON_UNUSED PyObj #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 138, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } - if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names, __pyx_t_1) < 0) __PYX_ERR(2, 138, __pyx_L1_error) + if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names, __pyx_t_1) < (0)) __PYX_ERR(2, 138, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_5 = NULL; @@ -41419,13 +40708,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_2__local(CYTHON_UNUSED PyObj #endif { PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 139, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } - if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs, __pyx_t_1) < 0) __PYX_ERR(2, 139, __pyx_L1_error) + if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs, __pyx_t_1) < (0)) __PYX_ERR(2, 139, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_4 = NULL; @@ -41445,16 +40734,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_2__local(CYTHON_UNUSED PyObj #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 140, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } - if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs, __pyx_t_1) < 0) __PYX_ERR(2, 140, __pyx_L1_error) + if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs, __pyx_t_1) < (0)) __PYX_ERR(2, 140, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid, Py_False) < 0) __PYX_ERR(2, 141, __pyx_L1_error) + if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid, Py_False) < (0)) __PYX_ERR(2, 141, __pyx_L1_error) __pyx_t_5 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ta_getFuncInfo); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 144, __pyx_L1_error) @@ -41475,82 +40764,46 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_2__local(CYTHON_UNUSED PyObj #endif { PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_7}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 144, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } - if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info, __pyx_t_1) < 0) __PYX_ERR(2, 144, __pyx_L1_error) + if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info, __pyx_t_1) < (0)) __PYX_ERR(2, 144, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_4 = NULL; - __Pyx_INCREF(__pyx_builtin_xrange); - __pyx_t_7 = __pyx_builtin_xrange; - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_8 = __pyx_t_9; - __Pyx_INCREF(__pyx_t_8); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = __pyx_t_8; + __Pyx_INCREF(__pyx_t_5); __pyx_t_6 = 0; { - PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_mstate_global->__pyx_n_u_num_inputs}; - __pyx_t_5 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_pop, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_num_inputs}; + __pyx_t_7 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_pop, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); } __pyx_t_6 = 1; { - PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_5}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_7}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(&PyRange_Type), __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 147, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } - if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { - __pyx_t_7 = __pyx_t_1; __Pyx_INCREF(__pyx_t_7); - __pyx_t_10 = 0; - __pyx_t_11 = NULL; - } else { - __pyx_t_10 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 147, __pyx_L1_error) - } + __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 147, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; for (;;) { - if (likely(!__pyx_t_11)) { - if (likely(PyList_CheckExact(__pyx_t_7))) { - { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_7); - #if !CYTHON_ASSUME_SAFE_SIZE - if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 147, __pyx_L1_error) - #endif - if (__pyx_t_10 >= __pyx_temp) break; - } - __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_7, __pyx_t_10); - ++__pyx_t_10; - } else { - { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_7); - #if !CYTHON_ASSUME_SAFE_SIZE - if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 147, __pyx_L1_error) - #endif - if (__pyx_t_10 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_10)); - #else - __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_7, __pyx_t_10); - #endif - ++__pyx_t_10; - } - if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 147, __pyx_L1_error) - } else { - __pyx_t_1 = __pyx_t_11(__pyx_t_7); + { + __pyx_t_1 = __pyx_t_9(__pyx_t_7); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { @@ -41564,29 +40817,29 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_2__local(CYTHON_UNUSED PyObj __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = NULL; - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ta_getInputParameterInfo); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_ta_getInputParameterInfo); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = 1; #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); - assert(__pyx_t_5); - PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_8); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(__pyx__function); - __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __Pyx_DECREF_SET(__pyx_t_8, __pyx__function); __pyx_t_6 = 0; } #endif { - PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_9, __pyx_v_i}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_5, __pyx_v_i}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 148, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } @@ -41606,96 +40859,60 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_2__local(CYTHON_UNUSED PyObj __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_INPUT_PRICE_SERIES_DEFAULTS); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 151, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 151, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely((PyObject_SetItem(__pyx_v_info, __pyx_mstate_global->__pyx_n_u_price_series, __pyx_t_4) < 0))) __PYX_ERR(2, 151, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely((PyObject_SetItem(__pyx_v_info, __pyx_mstate_global->__pyx_n_u_price_series, __pyx_t_8) < 0))) __PYX_ERR(2, 151, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 152, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (unlikely((PyObject_SetItem(__pyx_t_4, __pyx_v_input_name, __pyx_v_info) < 0))) __PYX_ERR(2, 152, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (unlikely((PyObject_SetItem(__pyx_t_8, __pyx_v_input_name, __pyx_v_info) < 0))) __PYX_ERR(2, 152, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 153, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (unlikely((PyObject_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_input_names, __pyx_t_7) < 0))) __PYX_ERR(2, 153, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (unlikely((PyObject_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_input_names, __pyx_t_7) < 0))) __PYX_ERR(2, 153, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = NULL; - __Pyx_INCREF(__pyx_builtin_xrange); - __pyx_t_1 = __pyx_builtin_xrange; - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 156, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_5 = __pyx_t_8; + __pyx_t_8 = NULL; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __pyx_t_4; __Pyx_INCREF(__pyx_t_5); __pyx_t_6 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_num_opt_inputs}; - __pyx_t_9 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_pop, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_pop, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 156, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); } __pyx_t_6 = 1; { - PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_9}; - __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_1}; + __pyx_t_7 = __Pyx_PyObject_FastCall((PyObject*)(&PyRange_Type), __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 156, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); } - if (likely(PyList_CheckExact(__pyx_t_7)) || PyTuple_CheckExact(__pyx_t_7)) { - __pyx_t_1 = __pyx_t_7; __Pyx_INCREF(__pyx_t_1); - __pyx_t_10 = 0; - __pyx_t_11 = NULL; - } else { - __pyx_t_10 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 156, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 156, __pyx_L1_error) - } + __pyx_t_1 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 156, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; for (;;) { - if (likely(!__pyx_t_11)) { - if (likely(PyList_CheckExact(__pyx_t_1))) { - { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_SIZE - if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 156, __pyx_L1_error) - #endif - if (__pyx_t_10 >= __pyx_temp) break; - } - __pyx_t_7 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_10); - ++__pyx_t_10; - } else { - { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_SIZE - if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 156, __pyx_L1_error) - #endif - if (__pyx_t_10 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_7 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_10)); - #else - __pyx_t_7 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_10); - #endif - ++__pyx_t_10; - } - if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 156, __pyx_L1_error) - } else { - __pyx_t_7 = __pyx_t_11(__pyx_t_1); + { + __pyx_t_7 = __pyx_t_9(__pyx_t_1); if (unlikely(!__pyx_t_7)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { @@ -41709,28 +40926,28 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_2__local(CYTHON_UNUSED PyObj __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_7); __pyx_t_7 = 0; - __pyx_t_9 = NULL; + __pyx_t_8 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ta_getOptInputParameterInfo); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 157, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = 1; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4); - assert(__pyx_t_9); + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_8); PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(__pyx__function); __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); __pyx_t_6 = 0; } #endif { - PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_t_8, __pyx_v_i}; - __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_t_5, __pyx_v_i}; + __pyx_t_7 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 157, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); @@ -41776,7 +40993,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_2__local(CYTHON_UNUSED PyObj #endif { PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 163, __pyx_L1_error) @@ -41789,71 +41006,35 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_2__local(CYTHON_UNUSED PyObj __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_4 = NULL; - __Pyx_INCREF(__pyx_builtin_xrange); - __pyx_t_7 = __pyx_builtin_xrange; - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 164, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_9 = __pyx_t_5; - __Pyx_INCREF(__pyx_t_9); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = __pyx_t_8; + __Pyx_INCREF(__pyx_t_5); __pyx_t_6 = 0; { - PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_mstate_global->__pyx_n_u_num_outputs}; - __pyx_t_8 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_pop, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 164, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_num_outputs}; + __pyx_t_7 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_pop, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); } __pyx_t_6 = 1; { - PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_8}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_7}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(&PyRange_Type), __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 164, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } - if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { - __pyx_t_7 = __pyx_t_1; __Pyx_INCREF(__pyx_t_7); - __pyx_t_10 = 0; - __pyx_t_11 = NULL; - } else { - __pyx_t_10 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 164, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 164, __pyx_L1_error) - } + __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 164, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; for (;;) { - if (likely(!__pyx_t_11)) { - if (likely(PyList_CheckExact(__pyx_t_7))) { - { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_7); - #if !CYTHON_ASSUME_SAFE_SIZE - if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 164, __pyx_L1_error) - #endif - if (__pyx_t_10 >= __pyx_temp) break; - } - __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_7, __pyx_t_10); - ++__pyx_t_10; - } else { - { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_7); - #if !CYTHON_ASSUME_SAFE_SIZE - if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 164, __pyx_L1_error) - #endif - if (__pyx_t_10 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_10)); - #else - __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_7, __pyx_t_10); - #endif - ++__pyx_t_10; - } - if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 164, __pyx_L1_error) - } else { - __pyx_t_1 = __pyx_t_11(__pyx_t_7); + { + __pyx_t_1 = __pyx_t_9(__pyx_t_7); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { @@ -41867,29 +41048,29 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_2__local(CYTHON_UNUSED PyObj __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_1); __pyx_t_1 = 0; - __pyx_t_8 = NULL; - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ta_getOutputParameterInfo); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 165, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_ta_getOutputParameterInfo); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 165, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = 1; #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); - assert(__pyx_t_8); - PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_8); + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_8); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(__pyx__function); - __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __Pyx_DECREF_SET(__pyx_t_8, __pyx__function); __pyx_t_6 = 0; } #endif { - PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_t_5, __pyx_v_i}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_5, __pyx_v_i}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 165, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } @@ -41903,11 +41084,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_2__local(CYTHON_UNUSED PyObj __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_info, __pyx_mstate_global->__pyx_n_u_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 167, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 167, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_output_flags); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 167, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_output_flags); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 167, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely((PyObject_SetItem(__pyx_t_5, __pyx_v_output_name, __pyx_t_1) < 0))) __PYX_ERR(2, 167, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -41943,7 +41124,6 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_2__local(CYTHON_UNUSED PyObj __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("talib._ta_lib.Function.__local", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -41967,7 +41147,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_4info, "Function.info(self)\nReturns a copy of the function's info dict."); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_4info, "Function.info(self)\n\nReturns a copy of the function's info dict."); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_5info = {"info", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_5info, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_4info}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_5info(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -41999,7 +41179,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 172, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 172, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -42010,7 +41190,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "info", 0) < 0) __PYX_ERR(2, 172, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "info", 0) < (0)) __PYX_ERR(2, 172, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("info", 1, 1, 1, i); __PYX_ERR(2, 172, __pyx_L3_error) } } @@ -42069,7 +41249,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_4info(CYTHON_UNUSED PyObject __pyx_t_5 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 177, __pyx_L1_error) @@ -42103,7 +41283,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_6function_flags, "Function.function_flags(self)\nReturns any function flags defined for this indicator function."); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_6function_flags, "Function.function_flags(self)\n\nReturns any function flags defined for this indicator function."); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_7function_flags = {"function_flags", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_7function_flags, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_6function_flags}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_7function_flags(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -42135,7 +41315,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 179, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 179, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -42146,7 +41326,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "function_flags", 0) < 0) __PYX_ERR(2, 179, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "function_flags", 0) < (0)) __PYX_ERR(2, 179, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("function_flags", 1, 1, 1, i); __PYX_ERR(2, 179, __pyx_L3_error) } } @@ -42226,7 +41406,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_8output_flags, "Function.output_flags(self)\nReturns the flags for each output for this indicator function."); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_8output_flags, "Function.output_flags(self)\n\nReturns the flags for each output for this indicator function."); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_9output_flags = {"output_flags", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_9output_flags, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_8output_flags}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_9output_flags(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -42258,7 +41438,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 186, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 186, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -42269,7 +41449,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "output_flags", 0) < 0) __PYX_ERR(2, 186, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "output_flags", 0) < (0)) __PYX_ERR(2, 186, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("output_flags", 1, 1, 1, i); __PYX_ERR(2, 186, __pyx_L3_error) } } @@ -42331,7 +41511,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_8output_flags(CYTHON_UNUSED __pyx_t_5 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 191, __pyx_L1_error) @@ -42365,7 +41545,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_10get_input_names, "Function.get_input_names(self)\nReturns the dict of input price series names that specifies which\nof the ndarrays in input_arrays will be used to calculate the function."); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_10get_input_names, "Function.get_input_names(self)\n\nReturns the dict of input price series names that specifies which\nof the ndarrays in input_arrays will be used to calculate the function."); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_11get_input_names = {"get_input_names", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_11get_input_names, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_10get_input_names}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_11get_input_names(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -42397,7 +41577,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 193, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 193, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -42408,7 +41588,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_input_names", 0) < 0) __PYX_ERR(2, 193, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_input_names", 0) < (0)) __PYX_ERR(2, 193, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_input_names", 1, 1, 1, i); __PYX_ERR(2, 193, __pyx_L3_error) } } @@ -42482,7 +41662,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_10get_input_names(CYTHON_UNU #endif { PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 199, __pyx_L1_error) @@ -42513,7 +41693,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_10get_input_names(CYTHON_UNU #endif if (__pyx_t_5 >= __pyx_temp) break; } - __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_5); + __pyx_t_1 = __Pyx_PyList_GetItemRefFast(__pyx_t_3, __pyx_t_5, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_5; } else { { @@ -42591,7 +41771,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_12set_input_names, "Function.set_input_names(self, input_names)\nSets the input price series names to use."); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_12set_input_names, "Function.set_input_names(self, input_names)\n\nSets the input price series names to use."); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_13set_input_names = {"set_input_names", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_13set_input_names, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_12set_input_names}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_13set_input_names(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -42624,7 +41804,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_input_names,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 204, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 204, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -42639,7 +41819,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "set_input_names", 0) < 0) __PYX_ERR(2, 204, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "set_input_names", 0) < (0)) __PYX_ERR(2, 204, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("set_input_names", 1, 2, 2, i); __PYX_ERR(2, 204, __pyx_L3_error) } } @@ -42707,7 +41887,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_12set_input_names(CYTHON_UNU __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_items, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_items, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -42732,7 +41912,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_12set_input_names(CYTHON_UNU #endif if (__pyx_t_4 >= __pyx_temp) break; } - __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_4); + __pyx_t_1 = __Pyx_PyList_GetItemRefFast(__pyx_t_2, __pyx_t_4, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_4; } else { { @@ -42777,10 +41957,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_12set_input_names(CYTHON_UNU __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1); __Pyx_INCREF(__pyx_t_7); } else { - __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 0); + __pyx_t_6 = __Pyx_PyList_GetItemRefFast(sequence, 0, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 209, __pyx_L1_error) __Pyx_XGOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyList_GetItemRef(sequence, 1); + __pyx_t_7 = __Pyx_PyList_GetItemRefFast(sequence, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 209, __pyx_L1_error) __Pyx_XGOTREF(__pyx_t_7); } @@ -42801,7 +41981,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_12set_input_names(CYTHON_UNU __Pyx_GOTREF(__pyx_t_6); index = 1; __pyx_t_7 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_7)) goto __pyx_L5_unpacking_failed; __Pyx_GOTREF(__pyx_t_7); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_8), 2) < 0) __PYX_ERR(2, 209, __pyx_L1_error) + if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_8), 2) < (0)) __PYX_ERR(2, 209, __pyx_L1_error) __pyx_t_9 = NULL; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L6_unpacking_done; @@ -42836,7 +42016,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_12set_input_names(CYTHON_UNU } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid, Py_False) < 0) __PYX_ERR(2, 212, __pyx_L1_error) + if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid, Py_False) < (0)) __PYX_ERR(2, 212, __pyx_L1_error) /* function exit code */ @@ -42868,7 +42048,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_14get_input_arrays, "Function.get_input_arrays(self)\nReturns a copy of the dict of input arrays in use."); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_14get_input_arrays, "Function.get_input_arrays(self)\n\nReturns a copy of the dict of input arrays in use."); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_15get_input_arrays = {"get_input_arrays", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_15get_input_arrays, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_14get_input_arrays}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_15get_input_arrays(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -42900,7 +42080,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 216, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 216, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -42911,7 +42091,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_input_arrays", 0) < 0) __PYX_ERR(2, 216, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_input_arrays", 0) < (0)) __PYX_ERR(2, 216, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_input_arrays", 1, 1, 1, i); __PYX_ERR(2, 216, __pyx_L3_error) } } @@ -42996,7 +42176,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_14get_input_arrays(CYTHON_UN __pyx_t_6 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; - __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_clone, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_clone, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 223, __pyx_L1_error) @@ -43017,7 +42197,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_14get_input_arrays(CYTHON_UN __pyx_t_6 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; - __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 225, __pyx_L1_error) @@ -43052,7 +42232,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_16set_input_arrays, "Function.set_input_arrays(self, input_arrays)\nSets the dict of input_arrays to use. Returns True/False for\nsubclasses:\n\nIf input_arrays is a dict with the keys open, high, low, close and\nvolume, it is assigned as the input_array to use and this function\nreturns True, returning False otherwise. If you implement your own\ndata type and wish to subclass Function, you should wrap this function\nwith an if-statement:\n\nclass CustomFunction(Function):\n def __init__(self, function_name):\n Function.__init__(self, function_name)\n\n def set_input_arrays(self, input_data):\n if Function.set_input_arrays(self, input_data):\n return True\n elif isinstance(input_data, some_module.CustomDataType):\n input_arrays = Function.get_input_arrays(self)\n # convert input_data to input_arrays and then call the super\n Function.set_input_arrays(self, input_arrays)\n return True\n return False"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_16set_input_arrays, "Function.set_input_arrays(self, input_arrays)\n\nSets the dict of input_arrays to use. Returns True/False for\nsubclasses:\n\nIf input_arrays is a dict with the keys open, high, low, close and\nvolume, it is assigned as the input_array to use and this function\nreturns True, returning False otherwise. If you implement your own\ndata type and wish to subclass Function, you should wrap this function\nwith an if-statement:\n\nclass CustomFunction(Function):\n def __init__(self, function_name):\n Function.__init__(self, function_name)\n\n def set_input_arrays(self, input_data):\n if Function.set_input_arrays(self, input_data):\n return True\n elif isinstance(input_data, some_module.CustomDataType):\n input_arrays = Function.get_input_arrays(self)\n # convert input_data to input_arrays and then call the super\n Function.set_input_arrays(self, input_arrays)\n return True\n return False"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_17set_input_arrays = {"set_input_arrays", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_17set_input_arrays, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_16set_input_arrays}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_17set_input_arrays(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -43085,7 +42265,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_input_arrays,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 227, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 227, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -43100,7 +42280,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "set_input_arrays", 0) < 0) __PYX_ERR(2, 227, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "set_input_arrays", 0) < (0)) __PYX_ERR(2, 227, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("set_input_arrays", 1, 2, 2, i); __PYX_ERR(2, 227, __pyx_L3_error) } } @@ -43155,9 +42335,8 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_16set_input_arrays(CYTHON_UN int __pyx_t_8; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; - PyObject *__pyx_t_11 = NULL; - PyObject *__pyx_t_12[4]; - PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_11[4]; + PyObject *__pyx_t_12 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -43184,7 +42363,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_16set_input_arrays(CYTHON_UN __pyx_t_4 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__input_price_series_na, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_Function__input_price_series_na, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -43209,7 +42388,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_16set_input_arrays(CYTHON_UN #endif if (__pyx_t_5 >= __pyx_temp) break; } - __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_5); + __pyx_t_1 = __Pyx_PyList_GetItemRefFast(__pyx_t_3, __pyx_t_5, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_5; } else { { @@ -43296,9 +42475,9 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_16set_input_arrays(CYTHON_UN __pyx_t_2 = (__pyx_t_5 == 0); if (likely(__pyx_t_2)) { - if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays, __pyx_v_input_arrays) < 0) __PYX_ERR(2, 264, __pyx_L1_error) + if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays, __pyx_v_input_arrays) < (0)) __PYX_ERR(2, 264, __pyx_L1_error) - if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid, Py_False) < 0) __PYX_ERR(2, 265, __pyx_L1_error) + if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid, Py_False) < (0)) __PYX_ERR(2, 265, __pyx_L1_error) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_True); @@ -43309,41 +42488,38 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_16set_input_arrays(CYTHON_UN /*else*/ { __pyx_t_1 = NULL; - __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception))); - __pyx_t_9 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); __pyx_t_5 = __Pyx_PyList_GET_SIZE(__pyx_v_missing_keys); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(2, 269, __pyx_L1_error) __pyx_t_2 = (__pyx_t_5 > 1); if (__pyx_t_2) { __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_s); - __pyx_t_10 = __pyx_mstate_global->__pyx_n_u_s; + __pyx_t_9 = __pyx_mstate_global->__pyx_n_u_s; } else { __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u__2); - __pyx_t_10 = __pyx_mstate_global->__pyx_kp_u__2; + __pyx_t_9 = __pyx_mstate_global->__pyx_kp_u__2; } - __pyx_t_11 = __Pyx_PyUnicode_Unicode(__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 269, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_11); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - - __pyx_t_10 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__3, __pyx_v_missing_keys); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 271, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyUnicode_Unicode(__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 269, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_12[0] = __pyx_mstate_global->__pyx_kp_u_input_arrays_parameter_missing_r; - __pyx_t_12[1] = __pyx_t_11; - __pyx_t_12[2] = __pyx_mstate_global->__pyx_kp_u_; - __pyx_t_12[3] = __pyx_t_10; - - __pyx_t_13 = __Pyx_PyUnicode_Join(__pyx_t_12, 4, 48 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_11) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_11) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_10)); - if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 268, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_13); - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + __pyx_t_9 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__3, __pyx_v_missing_keys); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_11[0] = __pyx_mstate_global->__pyx_kp_u_input_arrays_parameter_missing_r; + __pyx_t_11[1] = __pyx_t_10; + __pyx_t_11[2] = __pyx_mstate_global->__pyx_kp_u_; + __pyx_t_11[3] = __pyx_t_9; + + __pyx_t_12 = __Pyx_PyUnicode_Join(__pyx_t_11, 4, 48 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_10) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9)); + if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_4 = 1; { - PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_13}; - __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_12}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_Exception)), __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 268, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); } @@ -43366,8 +42542,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_16set_input_arrays(CYTHON_UN __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); - __Pyx_XDECREF(__pyx_t_11); - __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_12); __Pyx_AddTraceback("talib._ta_lib.Function.set_input_arrays", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -43389,7 +42564,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_18get_parameters, "Function.get_parameters(self)\nReturns the function's optional parameters and their default values."); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_18get_parameters, "Function.get_parameters(self)\n\nReturns the function's optional parameters and their default values."); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_19get_parameters = {"get_parameters", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_19get_parameters, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_18get_parameters}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_19get_parameters(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -43421,7 +42596,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 276, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 276, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -43432,7 +42607,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_parameters", 0) < 0) __PYX_ERR(2, 276, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_parameters", 0) < (0)) __PYX_ERR(2, 276, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_parameters", 1, 1, 1, i); __PYX_ERR(2, 276, __pyx_L3_error) } } @@ -43506,7 +42681,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_18get_parameters(CYTHON_UNUS #endif { PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 281, __pyx_L1_error) @@ -43537,7 +42712,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_18get_parameters(CYTHON_UNUS #endif if (__pyx_t_5 >= __pyx_temp) break; } - __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_5); + __pyx_t_1 = __Pyx_PyList_GetItemRefFast(__pyx_t_3, __pyx_t_5, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_5; } else { { @@ -43575,7 +42750,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_18get_parameters(CYTHON_UNUS __pyx_t_4 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_opt_input}; - __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__get_opt_input_value, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_Function__get_opt_input_value, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 283, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -43617,7 +42792,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_20set_parameters, "Function.set_parameters(self, parameters=None, **kwargs)\nSets the function parameter values."); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_20set_parameters, "Function.set_parameters(self, parameters=None, **kwargs)\n\nSets the function parameter values."); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_21set_parameters = {"set_parameters", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_21set_parameters, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_20set_parameters}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_21set_parameters(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -43653,7 +42828,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_parameters,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 286, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 286, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -43668,7 +42843,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "set_parameters", 1) < 0) __PYX_ERR(2, 286, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "set_parameters", 1) < (0)) __PYX_ERR(2, 286, __pyx_L3_error) if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None)); for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("set_parameters", 0, 1, 2, i); __PYX_ERR(2, 286, __pyx_L3_error) } @@ -43763,7 +42938,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_20set_parameters(CYTHON_UNUS __pyx_t_4 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_kwargs}; - __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_update, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_update, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 292, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -43775,7 +42950,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_20set_parameters(CYTHON_UNUS __pyx_t_4 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_items, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_items, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -43800,7 +42975,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_20set_parameters(CYTHON_UNUS #endif if (__pyx_t_5 >= __pyx_temp) break; } - __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_5); + __pyx_t_1 = __Pyx_PyList_GetItemRefFast(__pyx_t_3, __pyx_t_5, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_5; } else { { @@ -43845,10 +43020,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_20set_parameters(CYTHON_UNUS __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1); __Pyx_INCREF(__pyx_t_8); } else { - __pyx_t_7 = __Pyx_PyList_GetItemRef(sequence, 0); + __pyx_t_7 = __Pyx_PyList_GetItemRefFast(sequence, 0, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 293, __pyx_L1_error) __Pyx_XGOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyList_GetItemRef(sequence, 1); + __pyx_t_8 = __Pyx_PyList_GetItemRefFast(sequence, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 293, __pyx_L1_error) __Pyx_XGOTREF(__pyx_t_8); } @@ -43869,7 +43044,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_20set_parameters(CYTHON_UNUS __Pyx_GOTREF(__pyx_t_7); index = 1; __pyx_t_8 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_8)) goto __pyx_L7_unpacking_failed; __Pyx_GOTREF(__pyx_t_8); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 2) < 0) __PYX_ERR(2, 293, __pyx_L1_error) + if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 2) < (0)) __PYX_ERR(2, 293, __pyx_L1_error) __pyx_t_10 = NULL; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L8_unpacking_done; @@ -43890,7 +43065,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_20set_parameters(CYTHON_UNUS __pyx_t_4 = 0; { PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_v_param, __pyx_v_value}; - __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__check_opt_input_value, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_Function__check_opt_input_value, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 294, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -43912,7 +43087,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_20set_parameters(CYTHON_UNUS } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid, Py_False) < 0) __PYX_ERR(2, 296, __pyx_L1_error) + if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid, Py_False) < (0)) __PYX_ERR(2, 296, __pyx_L1_error) __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_parameters); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 297, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); @@ -43953,7 +43128,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_22set_function_args, "Function.set_function_args(self, *args, **kwargs)\noptional args:[input_arrays,] [parameter_args,] [input_price_series_kwargs,] [parameter_kwargs]"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_22set_function_args, "Function.set_function_args(self, *args, **kwargs)\n\noptional args:[input_arrays,] [parameter_args,] [input_price_series_kwargs,] [parameter_kwargs]"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_23set_function_args = {"set_function_args", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_23set_function_args, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_22set_function_args}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_23set_function_args(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -43996,7 +43171,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 301, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 301, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { default: @@ -44008,7 +43183,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } const Py_ssize_t kwd_pos_args = __pyx_nargs; const Py_ssize_t used_pos_args = (kwd_pos_args < 1) ? kwd_pos_args : 1; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, __pyx_kwds_len, "set_function_args", 1) < 0) __PYX_ERR(2, 301, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, __pyx_kwds_len, "set_function_args", 1) < (0)) __PYX_ERR(2, 301, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("set_function_args", 0, 1, 1, i); __PYX_ERR(2, 301, __pyx_L3_error) } } @@ -44111,7 +43286,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_22set_function_args(CYTHON_U __pyx_t_9 = 0; { PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_v_key, __pyx_v_value}; - __pyx_t_5 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__check_opt_input_value, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_Function__check_opt_input_value, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 311, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); @@ -44171,8 +43346,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_22set_function_args(CYTHON_U } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_7 = (__Pyx_PyTuple_GET_SIZE(__pyx_v_args) != 0); - if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_7 < 0))) __PYX_ERR(2, 318, __pyx_L1_error) + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_v_args); + if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(2, 318, __pyx_L1_error) + __pyx_t_7 = (__pyx_temp != 0); + } + if (__pyx_t_7) { __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); @@ -44180,12 +43359,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_22set_function_args(CYTHON_U __pyx_t_5 = __pyx_v_self; __Pyx_INCREF(__pyx_t_5); - __pyx_t_10 = __Pyx_GetItemInt_Tuple(__pyx_v_args, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 320, __pyx_L1_error) + __pyx_t_10 = __Pyx_GetItemInt_Tuple(__pyx_v_args, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 320, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_9 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_10}; - __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_set_input_arrays, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_set_input_arrays, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 320, __pyx_L1_error) @@ -44233,7 +43412,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_22set_function_args(CYTHON_U #endif if (__pyx_t_3 >= __pyx_temp) break; } - __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_5, __pyx_t_3); + __pyx_t_1 = __Pyx_PyList_GetItemRefFast(__pyx_t_5, __pyx_t_3, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_3; } else { { @@ -44297,7 +43476,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_22set_function_args(CYTHON_U __pyx_t_9 = 0; { PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_v_param_name, __pyx_v_value}; - __pyx_t_8 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__check_opt_input_value, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_8 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_Function__check_opt_input_value, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); @@ -44328,8 +43507,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_22set_function_args(CYTHON_U } - __pyx_t_12 = (__Pyx_PyTuple_GET_SIZE(__pyx_v_args) != 0); - if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_12 < 0))) __PYX_ERR(2, 331, __pyx_L1_error) + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_v_args); + if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(2, 331, __pyx_L1_error) + __pyx_t_12 = (__pyx_temp != 0); + } + if (!__pyx_t_12) { } else { __pyx_t_7 = __pyx_t_12; @@ -44352,7 +43535,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_22set_function_args(CYTHON_U } - if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid, Py_False) < 0) __PYX_ERR(2, 334, __pyx_L1_error) + if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid, Py_False) < (0)) __PYX_ERR(2, 334, __pyx_L1_error) } @@ -44388,7 +43571,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_24lookback, "Function.lookback(self)\nReturns the lookback window size for the function with the parameter\nvalues that are currently set."); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_24lookback, "Function.lookback(self)\n\nReturns the lookback window size for the function with the parameter\nvalues that are currently set."); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_25lookback = {"lookback", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_25lookback, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_24lookback}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_25lookback(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -44420,7 +43603,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 336, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 336, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -44431,7 +43614,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "lookback", 0) < 0) __PYX_ERR(2, 336, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "lookback", 0) < (0)) __PYX_ERR(2, 336, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("lookback", 1, 1, 1, i); __PYX_ERR(2, 336, __pyx_L3_error) } } @@ -44504,7 +43687,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_24lookback(CYTHON_UNUSED PyO __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 344, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_AsWritableString(__pyx_t_1); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(2, 344, __pyx_L1_error) - __pyx_t_3 = __pyx_f_5talib_7_ta_lib___ta_paramHolderAlloc(__pyx_t_2); if (unlikely(__pyx_t_3 == ((TA_ParamHolder *)0) && PyErr_Occurred())) __PYX_ERR(2, 344, __pyx_L1_error) + __pyx_t_3 = __pyx_f_5talib_7_ta_lib___ta_paramHolderAlloc(__pyx_t_2); if (unlikely(__pyx_t_3 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(2, 344, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_holder = __pyx_t_3; @@ -44532,7 +43715,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_24lookback(CYTHON_UNUSED PyO #endif if (__pyx_t_6 >= __pyx_temp) break; } - __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_5, __pyx_t_6); + __pyx_t_4 = __Pyx_PyList_GetItemRefFast(__pyx_t_5, __pyx_t_6, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_6; } else { { @@ -44577,7 +43760,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_24lookback(CYTHON_UNUSED PyO __pyx_t_9 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_v_opt_input}; - __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__get_opt_input_value, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_Function__get_opt_input_value, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 346, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); @@ -44697,7 +43880,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_26output_names, "Function.output_names(self)\nReturns a list of the output names returned by this function."); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_26output_names, "Function.output_names(self)\n\nReturns a list of the output names returned by this function."); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_27output_names = {"output_names", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_27output_names, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_26output_names}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_27output_names(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -44729,7 +43912,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 357, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 357, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -44740,7 +43923,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "output_names", 0) < 0) __PYX_ERR(2, 357, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "output_names", 0) < (0)) __PYX_ERR(2, 357, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("output_names", 1, 1, 1, i); __PYX_ERR(2, 357, __pyx_L3_error) } } @@ -44801,7 +43984,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_26output_names(CYTHON_UNUSED __pyx_t_5 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_keys, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_keys, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 362, __pyx_L1_error) @@ -44851,7 +44034,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_28outputs, "Function.outputs(self)\nReturns the TA function values for the currently set input_arrays and\nparameters. Returned values are a ndarray if there is only one output\nor a list of ndarrays for more than one output."); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_28outputs, "Function.outputs(self)\n\nReturns the TA function values for the currently set input_arrays and\nparameters. Returned values are a ndarray if there is only one output\nor a list of ndarrays for more than one output."); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_29outputs = {"outputs", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_29outputs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_28outputs}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_29outputs(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -44883,7 +44066,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 367, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 367, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -44894,7 +44077,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "outputs", 0) < 0) __PYX_ERR(2, 367, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "outputs", 0) < (0)) __PYX_ERR(2, 367, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("outputs", 1, 1, 1, i); __PYX_ERR(2, 367, __pyx_L3_error) } } @@ -44968,7 +44151,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_28outputs(CYTHON_UNUSED PyOb __pyx_t_5 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__call_function, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_Function__call_function, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 376, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -44984,7 +44167,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_28outputs(CYTHON_UNUSED PyOb __pyx_t_5 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_values, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_values, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 377, __pyx_L1_error) @@ -45042,7 +44225,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_28outputs(CYTHON_UNUSED PyOb __pyx_t_6 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_PANDAS_SERIES); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 384, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_ret, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 384, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_ret, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 384, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_5 = 1; #if CYTHON_UNPACK_METHODS @@ -45060,8 +44243,8 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_28outputs(CYTHON_UNUSED PyOb PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_8}; __pyx_t_9 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 384, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_index, __pyx_v_index, __pyx_t_9, __pyx_callargs+2, 0) < 0) __PYX_ERR(2, 384, __pyx_L1_error) - __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_9); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_index, __pyx_v_index, __pyx_t_9, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 384, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_9); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; @@ -45100,7 +44283,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_28outputs(CYTHON_UNUSED PyOb #endif { PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_ret}; - __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_11, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_11, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 386, __pyx_L1_error) @@ -45125,9 +44308,9 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_28outputs(CYTHON_UNUSED PyOb PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_4, __pyx_t_8}; __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 386, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_index, __pyx_v_index, __pyx_t_6, __pyx_callargs+2, 0) < 0) __PYX_ERR(2, 386, __pyx_L1_error) - if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_columns, __pyx_t_11, __pyx_t_6, __pyx_callargs+2, 1) < 0) __PYX_ERR(2, 386, __pyx_L1_error) - __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_9, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_index, __pyx_v_index, __pyx_t_6, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 386, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_columns, __pyx_t_11, __pyx_t_6, __pyx_callargs+2, 1) < (0)) __PYX_ERR(2, 386, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_9, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; @@ -45173,7 +44356,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_28outputs(CYTHON_UNUSED PyOb __pyx_t_1 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_POLARS_SERIES); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 392, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_ret, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 392, __pyx_L1_error) + __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_ret, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 392, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __pyx_t_5 = 1; #if CYTHON_UNPACK_METHODS @@ -45189,7 +44372,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_28outputs(CYTHON_UNUSED PyOb #endif { PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_11}; - __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_9 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; @@ -45227,7 +44410,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_28outputs(CYTHON_UNUSED PyOb #endif { PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_v_ret}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_10, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 394, __pyx_L1_error) @@ -45252,8 +44435,8 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_28outputs(CYTHON_UNUSED PyOb PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_1}; __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 394, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_schema, __pyx_t_10, __pyx_t_8, __pyx_callargs+2, 0) < 0) __PYX_ERR(2, 394, __pyx_L1_error) - __pyx_t_9 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_11, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_schema, __pyx_t_10, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 394, __pyx_L1_error) + __pyx_t_9 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_11, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; @@ -45274,7 +44457,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_28outputs(CYTHON_UNUSED PyOb __pyx_t_7 = PyObject_Length(__pyx_v_ret); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(2, 397, __pyx_L1_error) __pyx_t_2 = (__pyx_t_7 == 1); if (__pyx_t_2) { - __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_ret, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 397, __pyx_L1_error) + __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_ret, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 397, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __pyx_t_9 = __pyx_t_11; __pyx_t_11 = 0; @@ -45317,7 +44500,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_30run, "Function.run(self, input_arrays=None)\nrun([input_arrays=None])\n\nThis is a shortcut to the outputs property that also allows setting\nthe input_arrays dict."); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_30run, "Function.run(self, input_arrays=None)\n\nrun([input_arrays=None])\n\nThis is a shortcut to the outputs property that also allows setting\nthe input_arrays dict."); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_31run = {"run", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_31run, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_30run}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_31run(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -45350,7 +44533,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_input_arrays,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 399, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 399, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -45365,7 +44548,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "run", 0) < 0) __PYX_ERR(2, 399, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "run", 0) < (0)) __PYX_ERR(2, 399, __pyx_L3_error) if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None)); for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("run", 0, 1, 2, i); __PYX_ERR(2, 399, __pyx_L3_error) } @@ -45430,7 +44613,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_30run(CYTHON_UNUSED PyObject __pyx_t_4 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_input_arrays}; - __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_set_input_arrays, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_set_input_arrays, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 407, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); @@ -45444,7 +44627,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_30run(CYTHON_UNUSED PyObject __pyx_t_4 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__call_function, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_Function__call_function, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 408, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); @@ -45480,7 +44663,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_32__call__, "Function.__call__(self, *args, **kwargs)\nfunc_instance([input_arrays,] [parameter_args,] [input_price_series_kwargs,] [parameter_kwargs])\n\nThis is a shortcut to the outputs property that also allows setting\nthe input_arrays dict and function parameters."); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_32__call__, "Function.__call__(self, *args, **kwargs)\n\nfunc_instance([input_arrays,] [parameter_args,] [input_price_series_kwargs,] [parameter_kwargs])\n\nThis is a shortcut to the outputs property that also allows setting\nthe input_arrays dict and function parameters."); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_33__call__ = {"__call__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_33__call__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_32__call__}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_33__call__(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -45523,7 +44706,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 411, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 411, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { default: @@ -45535,7 +44718,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds } const Py_ssize_t kwd_pos_args = __pyx_nargs; const Py_ssize_t used_pos_args = (kwd_pos_args < 1) ? kwd_pos_args : 1; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, __pyx_kwds_len, "__call__", 1) < 0) __PYX_ERR(2, 411, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, __pyx_kwds_len, "__call__", 1) < (0)) __PYX_ERR(2, 411, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__call__", 0, 1, 1, i); __PYX_ERR(2, 411, __pyx_L3_error) } } @@ -45632,7 +44815,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO __pyx_t_5 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_keys, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_keys, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 421, __pyx_L1_error) @@ -45658,7 +44841,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO #endif if (__pyx_t_6 >= __pyx_temp) break; } - __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_4, __pyx_t_6); + __pyx_t_2 = __Pyx_PyList_GetItemRefFast(__pyx_t_4, __pyx_t_6, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_6; } else { { @@ -45740,7 +44923,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO #endif if (__pyx_t_6 >= __pyx_temp) break; } - __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_6); + __pyx_t_4 = __Pyx_PyList_GetItemRefFast(__pyx_t_3, __pyx_t_6, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_6; } else { { @@ -45812,7 +44995,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO __pyx_t_5 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__input_price_series_na, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_Function__input_price_series_na, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 428, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -45826,7 +45009,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO __pyx_t_8 = __pyx_t_9; goto __pyx_L10_bool_binop_done; } - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_args, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 429, __pyx_L1_error) + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_args, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 429, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_INPUT_ARRAYS_TYPES); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 429, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); @@ -45859,7 +45042,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO #endif if (__pyx_t_6 >= __pyx_temp) break; } - __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_6); + __pyx_t_2 = __Pyx_PyList_GetItemRefFast(__pyx_t_1, __pyx_t_6, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_6; } else { { @@ -45933,7 +45116,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_14 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_IndexError); + __pyx_t_14 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_IndexError)))); if (__pyx_t_14) { __Pyx_AddTraceback("talib._ta_lib.Function.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_4, &__pyx_t_15) < 0) __PYX_ERR(2, 436, __pyx_L17_except_error) @@ -45962,14 +45145,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO __pyx_t_20 = 0; __pyx_t_18 = NULL; - __Pyx_INCREF(__pyx_builtin_TypeError); - __pyx_t_17 = __pyx_builtin_TypeError; __pyx_t_5 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_18, __pyx_v_msg}; - __pyx_t_20 = __Pyx_PyObject_FastCall(__pyx_t_17, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_20 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_TypeError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 440, __pyx_L17_except_error) __Pyx_GOTREF(__pyx_t_20); } @@ -46061,7 +45241,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO __pyx_t_5 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_is_empty, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_is_empty, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 447, __pyx_L1_error) @@ -46095,7 +45275,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO __pyx_t_5 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_15, __pyx_v_input_arrays}; - __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_set_input_arrays, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_set_input_arrays, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 452, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -46132,7 +45312,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO __pyx_t_10 = __pyx_t_8; goto __pyx_L32_bool_binop_done; } - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_args, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 455, __pyx_L1_error) + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_args, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 455, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_INPUT_ARRAYS_TYPES); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 455, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); @@ -46166,14 +45346,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO __pyx_t_3 = 0; __pyx_t_1 = NULL; - __Pyx_INCREF(__pyx_builtin_TypeError); - __pyx_t_15 = __pyx_builtin_TypeError; __pyx_t_5 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_msg}; - __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_15, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_TypeError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 459, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); } @@ -46186,24 +45363,24 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_set_function_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 461, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_15 = __Pyx_PySequence_Tuple(__pyx_v_args); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 461, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __pyx_t_1 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 461, __pyx_L1_error) + __pyx_t_1 = __Pyx_PySequence_Tuple(__pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 461, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_15, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 461, __pyx_L1_error) + __pyx_t_15 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 461, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_1, __pyx_t_15); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 461, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_1 = __pyx_v_self; - __Pyx_INCREF(__pyx_t_1); + __pyx_t_15 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_15); __pyx_t_5 = 0; { - PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; - __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__call_function, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + PyObject *__pyx_callargs[2] = {__pyx_t_15, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_Function__call_function, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 462, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); } @@ -46219,12 +45396,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO #endif if (__pyx_t_16 >= __pyx_temp) break; } - __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_4, __pyx_t_16); + __pyx_t_15 = __Pyx_PyList_GetItemRefFast(__pyx_t_4, __pyx_t_16, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_16; - if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 465, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { - PyObject* sequence = __pyx_t_1; + if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 465, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + if ((likely(PyTuple_CheckExact(__pyx_t_15))) || (PyList_CheckExact(__pyx_t_15))) { + PyObject* sequence = __pyx_t_15; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); @@ -46233,36 +45410,36 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_15 = PyTuple_GET_ITEM(sequence, 0); - __Pyx_INCREF(__pyx_t_15); + __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_1); __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); __Pyx_INCREF(__pyx_t_3); } else { - __pyx_t_15 = __Pyx_PyList_GetItemRef(sequence, 0); - if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 465, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_15); - __pyx_t_3 = __Pyx_PyList_GetItemRef(sequence, 1); + __pyx_t_1 = __Pyx_PyList_GetItemRefFast(sequence, 0, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 465, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyList_GetItemRefFast(sequence, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 465, __pyx_L1_error) __Pyx_XGOTREF(__pyx_t_3); } #else - __pyx_t_15 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 465, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); + __pyx_t_1 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 465, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 465, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } else { Py_ssize_t index = -1; - __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 465, __pyx_L1_error) + __pyx_t_2 = PyObject_GetIter(__pyx_t_15); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 465, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __pyx_t_21 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); - index = 0; __pyx_t_15 = __pyx_t_21(__pyx_t_2); if (unlikely(!__pyx_t_15)) goto __pyx_L38_unpacking_failed; - __Pyx_GOTREF(__pyx_t_15); + index = 0; __pyx_t_1 = __pyx_t_21(__pyx_t_2); if (unlikely(!__pyx_t_1)) goto __pyx_L38_unpacking_failed; + __Pyx_GOTREF(__pyx_t_1); index = 1; __pyx_t_3 = __pyx_t_21(__pyx_t_2); if (unlikely(!__pyx_t_3)) goto __pyx_L38_unpacking_failed; __Pyx_GOTREF(__pyx_t_3); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_21(__pyx_t_2), 2) < 0) __PYX_ERR(2, 465, __pyx_L1_error) + if (__Pyx_IternextUnpackEndCheck(__pyx_t_21(__pyx_t_2), 2) < (0)) __PYX_ERR(2, 465, __pyx_L1_error) __pyx_t_21 = NULL; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; goto __pyx_L39_unpacking_done; @@ -46273,16 +45450,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO __PYX_ERR(2, 465, __pyx_L1_error) __pyx_L39_unpacking_done:; } - __Pyx_XDECREF_SET(__pyx_v_param_name, __pyx_t_15); - __pyx_t_15 = 0; + __Pyx_XDECREF_SET(__pyx_v_param_name, __pyx_t_1); + __pyx_t_1 = 0; __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 466, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_param_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 466, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 466, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_15, __pyx_v_param_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 466, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (unlikely((PyObject_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_value, __pyx_v_value) < 0))) __PYX_ERR(2, 466, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -46307,7 +45484,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO #endif if (__pyx_t_16 >= __pyx_temp) break; } - __pyx_t_3 = __Pyx_PyList_GetItemRef(__pyx_t_4, __pyx_t_16); + __pyx_t_3 = __Pyx_PyList_GetItemRefFast(__pyx_t_4, __pyx_t_16, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_16; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 470, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); @@ -46321,23 +45498,23 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0); - __Pyx_INCREF(__pyx_t_1); - __pyx_t_15 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_15 = PyTuple_GET_ITEM(sequence, 0); __Pyx_INCREF(__pyx_t_15); + __pyx_t_1 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_1); } else { - __pyx_t_1 = __Pyx_PyList_GetItemRef(sequence, 0); - if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 470, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_1); - __pyx_t_15 = __Pyx_PyList_GetItemRef(sequence, 1); + __pyx_t_15 = __Pyx_PyList_GetItemRefFast(sequence, 0, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 470, __pyx_L1_error) __Pyx_XGOTREF(__pyx_t_15); + __pyx_t_1 = __Pyx_PyList_GetItemRefFast(sequence, 1, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 470, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_1); } #else - __pyx_t_1 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 470, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_15 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 470, __pyx_L1_error) + __pyx_t_15 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 470, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); + __pyx_t_1 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 470, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); #endif __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { @@ -46346,11 +45523,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_21 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); - index = 0; __pyx_t_1 = __pyx_t_21(__pyx_t_2); if (unlikely(!__pyx_t_1)) goto __pyx_L43_unpacking_failed; - __Pyx_GOTREF(__pyx_t_1); - index = 1; __pyx_t_15 = __pyx_t_21(__pyx_t_2); if (unlikely(!__pyx_t_15)) goto __pyx_L43_unpacking_failed; + index = 0; __pyx_t_15 = __pyx_t_21(__pyx_t_2); if (unlikely(!__pyx_t_15)) goto __pyx_L43_unpacking_failed; __Pyx_GOTREF(__pyx_t_15); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_21(__pyx_t_2), 2) < 0) __PYX_ERR(2, 470, __pyx_L1_error) + index = 1; __pyx_t_1 = __pyx_t_21(__pyx_t_2); if (unlikely(!__pyx_t_1)) goto __pyx_L43_unpacking_failed; + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_21(__pyx_t_2), 2) < (0)) __PYX_ERR(2, 470, __pyx_L1_error) __pyx_t_21 = NULL; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; goto __pyx_L44_unpacking_done; @@ -46361,24 +45538,24 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO __PYX_ERR(2, 470, __pyx_L1_error) __pyx_L44_unpacking_done:; } - __Pyx_XDECREF_SET(__pyx_v_input_name, __pyx_t_1); - __pyx_t_1 = 0; - __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_15); + __Pyx_XDECREF_SET(__pyx_v_input_name, __pyx_t_15); __pyx_t_15 = 0; + __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_1); + __pyx_t_1 = 0; __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_15 = __Pyx_PyObject_GetItem(__pyx_t_3, __pyx_v_input_name); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 471, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); + __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_t_3, __pyx_v_input_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 471, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely((PyObject_SetItem(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_price_series, __pyx_v_value) < 0))) __PYX_ERR(2, 471, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_price_series, __pyx_v_value) < 0))) __PYX_ERR(2, 471, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 472, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 472, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 472, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 472, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely((PyObject_SetItem(__pyx_t_3, __pyx_v_input_name, __pyx_v_value) < 0))) __PYX_ERR(2, 472, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -46466,7 +45643,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 477, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 477, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -46477,7 +45654,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__input_price_series_names", 0) < 0) __PYX_ERR(2, 477, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__input_price_series_names", 0) < (0)) __PYX_ERR(2, 477, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__input_price_series_names", 1, 1, 1, i); __PYX_ERR(2, 477, __pyx_L3_error) } } @@ -46566,7 +45743,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_34__input_price_series_names #endif if (__pyx_t_3 >= __pyx_temp) break; } - __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_3); + __pyx_t_1 = __Pyx_PyList_GetItemRefFast(__pyx_t_2, __pyx_t_3, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_3; } else { { @@ -46632,7 +45809,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_34__input_price_series_names #endif if (__pyx_t_7 >= __pyx_temp) break; } - __pyx_t_5 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_7); + __pyx_t_5 = __Pyx_PyList_GetItemRefFast(__pyx_t_1, __pyx_t_7, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_7; } else { { @@ -46746,7 +45923,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 489, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 489, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -46757,7 +45934,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__call_function", 0) < 0) __PYX_ERR(2, 489, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__call_function", 0) < (0)) __PYX_ERR(2, 489, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__call_function", 1, 1, 1, i); __PYX_ERR(2, 489, __pyx_L3_error) } } @@ -46832,7 +46009,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_36__call_function(CYTHON_UNU __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__input_price_series_na, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_Function__input_price_series_na, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 491, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -46864,7 +46041,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_36__call_function(CYTHON_UNU #endif if (__pyx_t_4 >= __pyx_temp) break; } - __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_4); + __pyx_t_2 = __Pyx_PyList_GetItemRefFast(__pyx_t_1, __pyx_t_4, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_4; } else { { @@ -46931,7 +46108,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_36__call_function(CYTHON_UNU __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, ((PyObject *)(&PyFloat_Type))}; - __pyx_t_6 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 499, __pyx_L1_error) @@ -46967,7 +46144,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_36__call_function(CYTHON_UNU __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_10, NULL}; - __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_to_numpy, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_to_numpy, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 502, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); @@ -46977,7 +46154,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_36__call_function(CYTHON_UNU __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_9, ((PyObject *)(&PyFloat_Type))}; - __pyx_t_6 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 502, __pyx_L1_error) @@ -47016,7 +46193,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_36__call_function(CYTHON_UNU #endif if (__pyx_t_4 >= __pyx_temp) break; } - __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_6, __pyx_t_4); + __pyx_t_1 = __Pyx_PyList_GetItemRefFast(__pyx_t_6, __pyx_t_4, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_4; } else { { @@ -47054,7 +46231,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_36__call_function(CYTHON_UNU __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_opt_input}; - __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__get_opt_input_value, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_Function__get_opt_input_value, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 505, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -47088,7 +46265,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_36__call_function(CYTHON_UNU __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; - __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_keys, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_keys, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 511, __pyx_L1_error) @@ -47110,7 +46287,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_36__call_function(CYTHON_UNU __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_keys, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 514, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_keys, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (unlikely((PyObject_SetItem(__pyx_t_2, __pyx_t_6, __pyx_v_results) < 0))) __PYX_ERR(2, 514, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -47144,7 +46321,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_36__call_function(CYTHON_UNU #endif if (__pyx_t_4 >= __pyx_temp) break; } - __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_4); + __pyx_t_2 = __Pyx_PyList_GetItemRefFast(__pyx_t_1, __pyx_t_4, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_4; } else { { @@ -47198,7 +46375,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_36__call_function(CYTHON_UNU } __pyx_L14:; - if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid, Py_True) < 0) __PYX_ERR(2, 518, __pyx_L1_error) + if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid, Py_True) < (0)) __PYX_ERR(2, 518, __pyx_L1_error) /* function exit code */ @@ -47272,7 +46449,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_input_name,&__pyx_mstate_global->__pyx_n_u_value,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 520, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 520, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -47291,7 +46468,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__check_opt_input_value", 0) < 0) __PYX_ERR(2, 520, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__check_opt_input_value", 0) < (0)) __PYX_ERR(2, 520, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__check_opt_input_value", 1, 3, 3, i); __PYX_ERR(2, 520, __pyx_L3_error) } } @@ -47344,9 +46521,8 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_38__check_opt_input_value(CY PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; - PyObject *__pyx_t_9 = NULL; - PyObject *__pyx_t_10[7]; - size_t __pyx_t_11; + PyObject *__pyx_t_9[7]; + size_t __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -47442,42 +46618,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_38__check_opt_input_value(CY if (unlikely(__pyx_t_3)) { __pyx_t_1 = NULL; - __Pyx_INCREF(__pyx_builtin_TypeError); - __pyx_t_4 = __pyx_builtin_TypeError; - __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_input_name), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 532, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_input_name), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 532, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_type_, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 532, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_type_, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 532, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_t_6), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 532, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_t_7), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 532, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_value)), __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 532, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_t_6), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 532, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_value)), __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 532, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_9 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_t_7), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 532, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_10[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_parameter_value_for; - __pyx_t_10[1] = __pyx_t_6; - __pyx_t_10[2] = __pyx_mstate_global->__pyx_kp_u_expected; - __pyx_t_10[3] = __pyx_t_8; - __pyx_t_10[4] = __pyx_mstate_global->__pyx_kp_u_got; - __pyx_t_10[5] = __pyx_t_9; - __pyx_t_10[6] = __pyx_mstate_global->__pyx_kp_u__5; - - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_10, 7, 28 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 11 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8) + 6 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9)); - if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 531, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_9[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_parameter_value_for; + __pyx_t_9[1] = __pyx_t_4; + __pyx_t_9[2] = __pyx_mstate_global->__pyx_kp_u_expected; + __pyx_t_9[3] = __pyx_t_7; + __pyx_t_9[4] = __pyx_mstate_global->__pyx_kp_u_got; + __pyx_t_9[5] = __pyx_t_8; + __pyx_t_9[6] = __pyx_mstate_global->__pyx_kp_u__5; + + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_9, 7, 28 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + 11 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7) + 6 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8)); + if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 531, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_11 = 1; + __pyx_t_10 = 1; { - PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_7}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_6}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_TypeError)), __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 530, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } @@ -47501,7 +46674,6 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_38__check_opt_input_value(CY __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("talib._ta_lib.Function.__check_opt_input_value", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -47520,7 +46692,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_40__get_opt_input_value, "Function.__get_opt_input_value(self, input_name)\nReturns the user-set value if there is one, otherwise the default."); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_40__get_opt_input_value, "Function.__get_opt_input_value(self, input_name)\n\nReturns the user-set value if there is one, otherwise the default."); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_41__get_opt_input_value = {"__get_opt_input_value", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_41__get_opt_input_value, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_40__get_opt_input_value}; static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_41__get_opt_input_value(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -47553,7 +46725,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_input_name,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 535, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 535, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -47568,7 +46740,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__get_opt_input_value", 0) < 0) __PYX_ERR(2, 535, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__get_opt_input_value", 0) < (0)) __PYX_ERR(2, 535, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__get_opt_input_value", 1, 2, 2, i); __PYX_ERR(2, 535, __pyx_L3_error) } } @@ -47712,7 +46884,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 545, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 545, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -47723,7 +46895,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__repr__", 0) < 0) __PYX_ERR(2, 545, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__repr__", 0) < (0)) __PYX_ERR(2, 545, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__repr__", 1, 1, 1, i); __PYX_ERR(2, 545, __pyx_L3_error) } } @@ -47832,7 +47004,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 548, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 548, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -47843,7 +47015,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__unicode__", 0) < 0) __PYX_ERR(2, 548, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__unicode__", 0) < (0)) __PYX_ERR(2, 548, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__unicode__", 1, 1, 1, i); __PYX_ERR(2, 548, __pyx_L3_error) } } @@ -47895,7 +47067,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_44__unicode__(CYTHON_UNUSED __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_str, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_str, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 549, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -47961,7 +47133,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 551, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 551, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -47972,7 +47144,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__str__", 0) < 0) __PYX_ERR(2, 551, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__str__", 0) < (0)) __PYX_ERR(2, 551, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__str__", 1, 1, 1, i); __PYX_ERR(2, 551, __pyx_L3_error) } } @@ -48040,14 +47212,14 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_46__str__(CYTHON_UNUSED PyOb #endif { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_4}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 552, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } - __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 552, __pyx_L1_error) + __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 552, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_3; @@ -48072,7 +47244,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_46__str__(CYTHON_UNUSED PyOb /* Python wrapper */ static PyObject *__pyx_pw_5talib_7_ta_lib_349_ta_getGroupTable(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_348_ta_getGroupTable, "_ta_getGroupTable()\nReturns the list of available TALIB function group names. *slow*"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_348_ta_getGroupTable, "_ta_getGroupTable()\n\nReturns the list of available TALIB function group names. *slow*"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_349_ta_getGroupTable = {"_ta_getGroupTable", (PyCFunction)__pyx_pw_5talib_7_ta_lib_349_ta_getGroupTable, METH_NOARGS, __pyx_doc_5talib_7_ta_lib_348_ta_getGroupTable}; static PyObject *__pyx_pw_5talib_7_ta_lib_349_ta_getGroupTable(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; @@ -48154,7 +47326,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_350_ta_getFuncTable, "_ta_getFuncTable(char *group)\nReturns a list of the functions for the specified group name. *slow*"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_350_ta_getFuncTable, "_ta_getFuncTable(char *group)\n\nReturns a list of the functions for the specified group name. *slow*"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_351_ta_getFuncTable = {"_ta_getFuncTable", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_351_ta_getFuncTable, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_350_ta_getFuncTable}; static PyObject *__pyx_pw_5talib_7_ta_lib_351_ta_getFuncTable(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -48186,7 +47358,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_group,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 577, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 577, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -48197,7 +47369,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_getFuncTable", 0) < 0) __PYX_ERR(2, 577, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_getFuncTable", 0) < (0)) __PYX_ERR(2, 577, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_ta_getFuncTable", 1, 1, 1, i); __PYX_ERR(2, 577, __pyx_L3_error) } } @@ -48299,7 +47471,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_352__get_flags, "__get_flags(int flag, dict flags_lookup_dict)\nTA-LIB provides hints for multiple flags as a bitwise-ORed int.\nThis function returns the flags from flag found in the provided\nflags_lookup_dict."); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_352__get_flags, "__get_flags(int flag, dict flags_lookup_dict)\n\nTA-LIB provides hints for multiple flags as a bitwise-ORed int.\nThis function returns the flags from flag found in the provided\nflags_lookup_dict."); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_353__get_flags = {"__get_flags", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_353__get_flags, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_352__get_flags}; static PyObject *__pyx_pw_5talib_7_ta_lib_353__get_flags(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -48332,7 +47504,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_flag,&__pyx_mstate_global->__pyx_n_u_flags_lookup_dict,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 589, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 589, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -48347,7 +47519,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__get_flags", 0) < 0) __PYX_ERR(2, 589, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__get_flags", 0) < (0)) __PYX_ERR(2, 589, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__get_flags", 1, 2, 2, i); __PYX_ERR(2, 589, __pyx_L3_error) } } @@ -48410,11 +47582,9 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_352__get_flags(CYTHON_UNUSED PyObject PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - size_t __pyx_t_9; - Py_ssize_t __pyx_t_10; - PyObject *(*__pyx_t_11)(PyObject *); - int __pyx_t_12; + size_t __pyx_t_8; + PyObject *(*__pyx_t_9)(PyObject *); + int __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -48447,18 +47617,15 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_352__get_flags(CYTHON_UNUSED PyObject __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_7 = NULL; - __Pyx_INCREF(__pyx_builtin_min); - __pyx_t_8 = __pyx_builtin_min; - __pyx_t_9 = 1; + __pyx_t_8 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_value_range}; - __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_min, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 598, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); } - __pyx_t_9 = 1; + __pyx_t_8 = 1; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); @@ -48467,12 +47634,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_352__get_flags(CYTHON_UNUSED PyObject __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(__pyx__function); __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); - __pyx_t_9 = 0; + __pyx_t_8 = 0; } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_5, __pyx_mstate_global->__pyx_int_2}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; @@ -48491,19 +47658,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_352__get_flags(CYTHON_UNUSED PyObject __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_log); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 599, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_8 = NULL; - __Pyx_INCREF(__pyx_builtin_max); - __pyx_t_7 = __pyx_builtin_max; - __pyx_t_9 = 1; + __pyx_t_7 = NULL; + __pyx_t_8 = 1; { - PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_v_value_range}; - __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_value_range}; + __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_max, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 599, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); } - __pyx_t_9 = 1; + __pyx_t_8 = 1; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); @@ -48512,12 +47676,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_352__get_flags(CYTHON_UNUSED PyObject __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(__pyx__function); __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); - __pyx_t_9 = 0; + __pyx_t_8 = 0; } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_5, __pyx_mstate_global->__pyx_int_2}; - __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_6 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; @@ -48561,60 +47725,24 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_352__get_flags(CYTHON_UNUSED PyObject __pyx_t_5 = 0; __pyx_t_6 = NULL; - __Pyx_INCREF(__pyx_builtin_xrange); - __pyx_t_4 = __pyx_builtin_xrange; - __pyx_t_1 = __Pyx_PyLong_AddObjC(__pyx_v_max_int, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 609, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_9 = 1; + __pyx_t_4 = __Pyx_PyLong_AddObjC(__pyx_v_max_int, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 609, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = 1; { - PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_v_min_int, __pyx_t_1}; - __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_v_min_int, __pyx_t_4}; + __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)(&PyRange_Type), __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 609, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); } - if (likely(PyList_CheckExact(__pyx_t_5)) || PyTuple_CheckExact(__pyx_t_5)) { - __pyx_t_4 = __pyx_t_5; __Pyx_INCREF(__pyx_t_4); - __pyx_t_10 = 0; - __pyx_t_11 = NULL; - } else { - __pyx_t_10 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 609, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 609, __pyx_L1_error) - } + __pyx_t_4 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 609, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 609, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; for (;;) { - if (likely(!__pyx_t_11)) { - if (likely(PyList_CheckExact(__pyx_t_4))) { - { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4); - #if !CYTHON_ASSUME_SAFE_SIZE - if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 609, __pyx_L1_error) - #endif - if (__pyx_t_10 >= __pyx_temp) break; - } - __pyx_t_5 = __Pyx_PyList_GetItemRef(__pyx_t_4, __pyx_t_10); - ++__pyx_t_10; - } else { - { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_4); - #if !CYTHON_ASSUME_SAFE_SIZE - if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 609, __pyx_L1_error) - #endif - if (__pyx_t_10 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_10)); - #else - __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_10); - #endif - ++__pyx_t_10; - } - if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 609, __pyx_L1_error) - } else { - __pyx_t_5 = __pyx_t_11(__pyx_t_4); + { + __pyx_t_5 = __pyx_t_9(__pyx_t_4); if (unlikely(!__pyx_t_5)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { @@ -48625,33 +47753,33 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_352__get_flags(CYTHON_UNUSED PyObject } } __Pyx_GOTREF(__pyx_t_5); - if (!(likely(PyLong_CheckExact(__pyx_t_5))||((__pyx_t_5) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_5))) __PYX_ERR(2, 609, __pyx_L1_error) + if (__Pyx_PyInt_FromNumber(&__pyx_t_5, NULL, 1) < (0)) __PYX_ERR(2, 609, __pyx_L1_error) __Pyx_XDECREF_SET(__pyx_v_i, ((PyObject*)__pyx_t_5)); __pyx_t_5 = 0; __pyx_t_5 = PyNumber_Power(__pyx_mstate_global->__pyx_int_2, __pyx_v_i, Py_None); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 610, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_flag); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 610, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_6 = PyNumber_And(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 610, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_flag); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 610, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = PyNumber_And(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 610, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(2, 610, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(2, 610, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_3) { if (unlikely(__pyx_v_flags_lookup_dict == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(2, 611, __pyx_L1_error) } - __pyx_t_6 = PyNumber_Power(__pyx_mstate_global->__pyx_int_2, __pyx_v_i, Py_None); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 611, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_flags_lookup_dict, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 611, __pyx_L1_error) + __pyx_t_1 = PyNumber_Power(__pyx_mstate_global->__pyx_int_2, __pyx_v_i, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 611, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_ret, __pyx_t_1); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(2, 611, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_GetItem(__pyx_v_flags_lookup_dict, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 611, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_ret, __pyx_t_6); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(2, 611, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } @@ -48671,7 +47799,6 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_352__get_flags(CYTHON_UNUSED PyObject __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("talib._ta_lib.__get_flags", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -48694,7 +47821,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_354_ta_getFuncInfo, "_ta_getFuncInfo(char *function_name)\nReturns the info dict for the function. It has the following keys: name,\ngroup, help, flags, num_inputs, num_opt_inputs and num_outputs."); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_354_ta_getFuncInfo, "_ta_getFuncInfo(char *function_name)\n\nReturns the info dict for the function. It has the following keys: name,\ngroup, help, flags, num_inputs, num_opt_inputs and num_outputs."); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_355_ta_getFuncInfo = {"_ta_getFuncInfo", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_355_ta_getFuncInfo, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_354_ta_getFuncInfo}; static PyObject *__pyx_pw_5talib_7_ta_lib_355_ta_getFuncInfo(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -48726,7 +47853,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_function_name,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 648, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 648, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -48737,7 +47864,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_getFuncInfo", 0) < 0) __PYX_ERR(2, 648, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_getFuncInfo", 0) < (0)) __PYX_ERR(2, 648, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_ta_getFuncInfo", 1, 1, 1, i); __PYX_ERR(2, 648, __pyx_L3_error) } } @@ -48790,7 +47917,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_354_ta_getFuncInfo(CYTHON_UNUSED PyObj int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_ta_getFuncInfo", 0); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name); if (unlikely(__pyx_t_1 == ((TA_FuncHandle const *)0) && PyErr_Occurred())) __PYX_ERR(2, 654, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name); if (unlikely(__pyx_t_1 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(2, 654, __pyx_L1_error) __pyx_v_retCode = TA_GetFuncInfo(__pyx_t_1, (&__pyx_v_info)); __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GetFuncInfo, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 655, __pyx_L1_error) @@ -48820,14 +47947,14 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_354_ta_getFuncInfo(CYTHON_UNUSED PyObj #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_6}; - __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 658, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); } - if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_name, __pyx_t_3) < 0) __PYX_ERR(2, 658, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_name, __pyx_t_3) < (0)) __PYX_ERR(2, 658, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = NULL; @@ -48849,14 +47976,14 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_354_ta_getFuncInfo(CYTHON_UNUSED PyObj #endif { PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; - __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 659, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); } - if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_group, __pyx_t_3) < 0) __PYX_ERR(2, 658, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_group, __pyx_t_3) < (0)) __PYX_ERR(2, 658, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = NULL; @@ -48878,14 +48005,14 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_354_ta_getFuncInfo(CYTHON_UNUSED PyObj #endif { PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; - __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 660, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); } - if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_display_name, __pyx_t_3) < 0) __PYX_ERR(2, 658, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_display_name, __pyx_t_3) < (0)) __PYX_ERR(2, 658, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_4 = NULL; @@ -48909,7 +48036,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_354_ta_getFuncInfo(CYTHON_UNUSED PyObj #endif { PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_6, __pyx_t_8}; - __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -48917,61 +48044,52 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_354_ta_getFuncInfo(CYTHON_UNUSED PyObj if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 661, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); } - if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_function_flags, __pyx_t_3) < 0) __PYX_ERR(2, 658, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_function_flags, __pyx_t_3) < (0)) __PYX_ERR(2, 658, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = NULL; - __Pyx_INCREF((PyObject *)(&PyLong_Type)); - __pyx_t_8 = ((PyObject *)(&PyLong_Type)); - __pyx_t_6 = __Pyx_PyLong_From_unsigned_int(__pyx_v_info->nbInput); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 662, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyLong_From_unsigned_int(__pyx_v_info->nbInput); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 662, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = 1; { - PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_6}; - __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_8}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(&PyLong_Type), __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 662, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); } - if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_num_inputs, __pyx_t_3) < 0) __PYX_ERR(2, 658, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_num_inputs, __pyx_t_3) < (0)) __PYX_ERR(2, 658, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_8 = NULL; - __Pyx_INCREF((PyObject *)(&PyLong_Type)); - __pyx_t_6 = ((PyObject *)(&PyLong_Type)); __pyx_t_5 = __Pyx_PyLong_From_unsigned_int(__pyx_v_info->nbOptInput); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 663, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_5}; - __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(&PyLong_Type), __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 663, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); } - if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_num_opt_inputs, __pyx_t_3) < 0) __PYX_ERR(2, 658, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_num_opt_inputs, __pyx_t_3) < (0)) __PYX_ERR(2, 658, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = NULL; - __Pyx_INCREF((PyObject *)(&PyLong_Type)); - __pyx_t_5 = ((PyObject *)(&PyLong_Type)); + __pyx_t_5 = NULL; __pyx_t_8 = __Pyx_PyLong_From_unsigned_int(__pyx_v_info->nbOutput); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 664, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = 1; { - PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_8}; - __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_8}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(&PyLong_Type), __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 664, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); } - if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_num_outputs, __pyx_t_3) < 0) __PYX_ERR(2, 658, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_num_outputs, __pyx_t_3) < (0)) __PYX_ERR(2, 658, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; @@ -49003,7 +48121,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_356_ta_getInputParameterInfo, "_ta_getInputParameterInfo(char *function_name, int idx)\nReturns the function's input info dict for the given index. It has two\nkeys: name and flags."); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_356_ta_getInputParameterInfo, "_ta_getInputParameterInfo(char *function_name, int idx)\n\nReturns the function's input info dict for the given index. It has two\nkeys: name and flags."); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_357_ta_getInputParameterInfo = {"_ta_getInputParameterInfo", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_357_ta_getInputParameterInfo, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_356_ta_getInputParameterInfo}; static PyObject *__pyx_pw_5talib_7_ta_lib_357_ta_getInputParameterInfo(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -49036,7 +48154,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_function_name,&__pyx_mstate_global->__pyx_n_u_idx,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 667, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 667, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -49051,7 +48169,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_getInputParameterInfo", 0) < 0) __PYX_ERR(2, 667, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_getInputParameterInfo", 0) < (0)) __PYX_ERR(2, 667, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_ta_getInputParameterInfo", 1, 2, 2, i); __PYX_ERR(2, 667, __pyx_L3_error) } } @@ -49110,7 +48228,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_356_ta_getInputParameterInfo(CYTHON_UN int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_ta_getInputParameterInfo", 0); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name); if (unlikely(__pyx_t_1 == ((TA_FuncHandle const *)0) && PyErr_Occurred())) __PYX_ERR(2, 673, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name); if (unlikely(__pyx_t_1 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(2, 673, __pyx_L1_error) __pyx_v_retCode = TA_GetInputParameterInfo(__pyx_t_1, __pyx_v_idx, (&__pyx_v_info)); __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GetInputParameterInfo, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 674, __pyx_L1_error) @@ -49136,7 +48254,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_356_ta_getInputParameterInfo(CYTHON_UN #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; @@ -49154,7 +48272,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_356_ta_getInputParameterInfo(CYTHON_UN __pyx_t_6 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; - __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_lower, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_lower, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 677, __pyx_L1_error) @@ -49190,7 +48308,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_356_ta_getInputParameterInfo(CYTHON_UN __pyx_t_5 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 684, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_name, __pyx_v_name) < 0) __PYX_ERR(2, 684, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_name, __pyx_v_name) < (0)) __PYX_ERR(2, 684, __pyx_L1_error) __pyx_t_4 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 685, __pyx_L1_error) @@ -49213,7 +48331,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_356_ta_getInputParameterInfo(CYTHON_UN #endif { PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_9, __pyx_t_10}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; @@ -49221,7 +48339,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_356_ta_getInputParameterInfo(CYTHON_UN if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } - if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_price_series, __pyx_t_2) < 0) __PYX_ERR(2, 684, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_price_series, __pyx_t_2) < (0)) __PYX_ERR(2, 684, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; @@ -49254,7 +48372,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_358_ta_getOptInputParameterInfo, "_ta_getOptInputParameterInfo(char *function_name, int idx)\nReturns the function's opt_input info dict for the given index. It has the\nfollowing keys: name, display_name, type, help, default_value and value."); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_358_ta_getOptInputParameterInfo, "_ta_getOptInputParameterInfo(char *function_name, int idx)\n\nReturns the function's opt_input info dict for the given index. It has the\nfollowing keys: name, display_name, type, help, default_value and value."); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_359_ta_getOptInputParameterInfo = {"_ta_getOptInputParameterInfo", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_359_ta_getOptInputParameterInfo, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_358_ta_getOptInputParameterInfo}; static PyObject *__pyx_pw_5talib_7_ta_lib_359_ta_getOptInputParameterInfo(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -49287,7 +48405,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_function_name,&__pyx_mstate_global->__pyx_n_u_idx,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 688, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 688, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -49302,7 +48420,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_getOptInputParameterInfo", 0) < 0) __PYX_ERR(2, 688, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_getOptInputParameterInfo", 0) < (0)) __PYX_ERR(2, 688, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_ta_getOptInputParameterInfo", 1, 2, 2, i); __PYX_ERR(2, 688, __pyx_L3_error) } } @@ -49344,7 +48462,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_358_ta_getOptInputParameterInfo(CYTHON TA_OptInputParameterInfo const *__pyx_v_info; TA_RetCode __pyx_v_retCode; PyObject *__pyx_v_name = NULL; - double __pyx_v_default_value; + PyObject *__pyx_v_default_value = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations TA_FuncHandle const *__pyx_t_1; @@ -49354,17 +48472,14 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_358_ta_getOptInputParameterInfo(CYTHON PyObject *__pyx_t_5 = NULL; size_t __pyx_t_6; Py_ssize_t __pyx_t_7; - TA_Real __pyx_t_8; - int __pyx_t_9; - int __pyx_t_10; - double __pyx_t_11; - PyObject *__pyx_t_12 = NULL; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_ta_getOptInputParameterInfo", 0); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name); if (unlikely(__pyx_t_1 == ((TA_FuncHandle const *)0) && PyErr_Occurred())) __PYX_ERR(2, 694, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name); if (unlikely(__pyx_t_1 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(2, 694, __pyx_L1_error) __pyx_v_retCode = TA_GetOptInputParameterInfo(__pyx_t_1, __pyx_v_idx, (&__pyx_v_info)); __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GetOptInputParameterInfo, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 695, __pyx_L1_error) @@ -49390,7 +48505,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_358_ta_getOptInputParameterInfo(CYTHON #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; @@ -49408,7 +48523,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_358_ta_getOptInputParameterInfo(CYTHON __pyx_t_6 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; - __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_lower, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_lower, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 698, __pyx_L1_error) @@ -49417,36 +48532,32 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_358_ta_getOptInputParameterInfo(CYTHON __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_2); __pyx_t_2 = 0; - __pyx_t_8 = __pyx_v_info->defaultValue; - __pyx_v_default_value = __pyx_t_8; - - __pyx_t_10 = (__Pyx_mod_double(__pyx_v_default_value, 1.0, 1) == 0.0); - if (__pyx_t_10) { + __pyx_t_8 = (__pyx_v_info->type > 1); + if (__pyx_t_8) { + __pyx_t_5 = PyLong_FromDouble(__pyx_v_info->defaultValue); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 699, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __pyx_t_5; + __pyx_t_5 = 0; } else { - __pyx_t_9 = __pyx_t_10; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_10 = (__pyx_v_info->type > 1); - __pyx_t_9 = __pyx_t_10; - __pyx_L4_bool_binop_done:; - if (__pyx_t_9) { - - __pyx_t_11 = trunc(__pyx_v_default_value); - __pyx_v_default_value = __pyx_t_11; - + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_info->defaultValue); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 699, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __pyx_t_5; + __pyx_t_5 = 0; } + __pyx_v_default_value = __pyx_t_2; + __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 704, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 702, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_name, __pyx_v_name) < 0) __PYX_ERR(2, 704, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_name, __pyx_v_name) < (0)) __PYX_ERR(2, 702, __pyx_L1_error) __pyx_t_4 = NULL; - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_bytes2str); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 705, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_bytes2str); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 703, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_12 = __Pyx_PyBytes_FromString(__pyx_v_info->displayName); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 705, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_12); + __pyx_t_9 = __Pyx_PyBytes_FromString(__pyx_v_info->displayName); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 703, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); __pyx_t_6 = 1; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_3))) { @@ -49460,57 +48571,54 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_358_ta_getOptInputParameterInfo(CYTHON } #endif { - PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_12}; - __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_9}; + __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 705, __pyx_L1_error) + if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 703, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); } - if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_display_name, __pyx_t_5) < 0) __PYX_ERR(2, 704, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_display_name, __pyx_t_5) < (0)) __PYX_ERR(2, 702, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyLong_From_TA_OptInputParameterType(__pyx_v_info->type); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 706, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyLong_From_TA_OptInputParameterType(__pyx_v_info->type); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 704, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_type_2, __pyx_t_5) < 0) __PYX_ERR(2, 704, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_type_2, __pyx_t_5) < (0)) __PYX_ERR(2, 702, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_3 = NULL; - __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_bytes2str); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 707, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_12); - __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_info->hint); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 707, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_bytes2str); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 705, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_info->hint); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 705, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = 1; #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_12))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_12); + if (unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_9); assert(__pyx_t_3); - PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx__function); - __Pyx_DECREF_SET(__pyx_t_12, __pyx__function); + __Pyx_DECREF_SET(__pyx_t_9, __pyx__function); __pyx_t_6 = 0; } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4}; - __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_12, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_9, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 707, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 705, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); } - if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_help, __pyx_t_5) < 0) __PYX_ERR(2, 704, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_help, __pyx_t_5) < (0)) __PYX_ERR(2, 702, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_default_value); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 708, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_default_value, __pyx_t_5) < 0) __PYX_ERR(2, 704, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_default_value, __pyx_v_default_value) < (0)) __PYX_ERR(2, 702, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_value, Py_None) < 0) __PYX_ERR(2, 704, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_value, Py_None) < (0)) __PYX_ERR(2, 702, __pyx_L1_error) __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; @@ -49522,11 +48630,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_358_ta_getOptInputParameterInfo(CYTHON __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("talib._ta_lib._ta_getOptInputParameterInfo", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_name); + __Pyx_XDECREF(__pyx_v_default_value); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -49541,7 +48650,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_360_ta_getOutputParameterInfo, "_ta_getOutputParameterInfo(char *function_name, int idx)\nReturns the function's output info dict for the given index. It has two\nkeys: name and flags."); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_360_ta_getOutputParameterInfo, "_ta_getOutputParameterInfo(char *function_name, int idx)\n\nReturns the function's output info dict for the given index. It has two\nkeys: name and flags."); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_361_ta_getOutputParameterInfo = {"_ta_getOutputParameterInfo", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_361_ta_getOutputParameterInfo, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_360_ta_getOutputParameterInfo}; static PyObject *__pyx_pw_5talib_7_ta_lib_361_ta_getOutputParameterInfo(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -49574,39 +48683,39 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_function_name,&__pyx_mstate_global->__pyx_n_u_idx,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 712, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 710, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); - if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 712, __pyx_L3_error) + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 710, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); - if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 712, __pyx_L3_error) + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 710, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_getOutputParameterInfo", 0) < 0) __PYX_ERR(2, 712, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_getOutputParameterInfo", 0) < (0)) __PYX_ERR(2, 710, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { - if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_ta_getOutputParameterInfo", 1, 2, 2, i); __PYX_ERR(2, 712, __pyx_L3_error) } + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_ta_getOutputParameterInfo", 1, 2, 2, i); __PYX_ERR(2, 710, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); - if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 712, __pyx_L3_error) + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 710, __pyx_L3_error) values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); - if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 712, __pyx_L3_error) + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 710, __pyx_L3_error) } - __pyx_v_function_name = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_function_name) && PyErr_Occurred())) __PYX_ERR(2, 712, __pyx_L3_error) - __pyx_v_idx = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_idx == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 712, __pyx_L3_error) + __pyx_v_function_name = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_function_name) && PyErr_Occurred())) __PYX_ERR(2, 710, __pyx_L3_error) + __pyx_v_idx = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_idx == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 710, __pyx_L3_error) } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("_ta_getOutputParameterInfo", 1, 2, 2, __pyx_nargs); __PYX_ERR(2, 712, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_ta_getOutputParameterInfo", 1, 2, 2, __pyx_nargs); __PYX_ERR(2, 710, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -49650,17 +48759,17 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_360_ta_getOutputParameterInfo(CYTHON_U int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_ta_getOutputParameterInfo", 0); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name); if (unlikely(__pyx_t_1 == ((TA_FuncHandle const *)0) && PyErr_Occurred())) __PYX_ERR(2, 718, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name); if (unlikely(__pyx_t_1 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(2, 716, __pyx_L1_error) __pyx_v_retCode = TA_GetOutputParameterInfo(__pyx_t_1, __pyx_v_idx, (&__pyx_v_info)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GetOutputParameterInfo, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 719, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GetOutputParameterInfo, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 717, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = NULL; - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_bytes2str); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 721, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_bytes2str); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 719, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_info->paramName); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 721, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_info->paramName); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 719, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = 1; #if CYTHON_UNPACK_METHODS @@ -49676,34 +48785,34 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_360_ta_getOutputParameterInfo(CYTHON_U #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 721, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 719, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } __pyx_v_name = __pyx_t_2; __pyx_t_2 = 0; - __pyx_t_7 = __Pyx_PyUnicode_GET_LENGTH(__pyx_mstate_global->__pyx_n_u_out); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(2, 722, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_GetSlice(__pyx_v_name, __pyx_t_7, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 722, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_GET_LENGTH(__pyx_mstate_global->__pyx_n_u_out); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(2, 720, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetSlice(__pyx_v_name, __pyx_t_7, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 720, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __pyx_t_5; __Pyx_INCREF(__pyx_t_4); __pyx_t_6 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; - __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_lower, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_lower, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 722, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 720, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_2); __pyx_t_2 = 0; - __pyx_t_9 = (__Pyx_PySequence_ContainsTF(__pyx_mstate_global->__pyx_n_u_real, __pyx_v_name, Py_EQ)); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(2, 724, __pyx_L1_error) + __pyx_t_9 = (__Pyx_PySequence_ContainsTF(__pyx_mstate_global->__pyx_n_u_real, __pyx_v_name, Py_EQ)); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(2, 722, __pyx_L1_error) if (__pyx_t_9) { } else { __pyx_t_8 = __pyx_t_9; @@ -49711,19 +48820,19 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_360_ta_getOutputParameterInfo(CYTHON_U } __Pyx_INCREF(__pyx_v_name); __pyx_t_2 = __pyx_v_name; - __pyx_t_10 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_real, Py_NE)); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(2, 724, __pyx_L1_error) + __pyx_t_10 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_real, Py_NE)); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(2, 722, __pyx_L1_error) if (__pyx_t_10) { } else { __pyx_t_9 = __pyx_t_10; goto __pyx_L6_bool_binop_done; } - __pyx_t_10 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_real0, Py_NE)); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(2, 724, __pyx_L1_error) + __pyx_t_10 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_real0, Py_NE)); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(2, 722, __pyx_L1_error) if (__pyx_t_10) { } else { __pyx_t_9 = __pyx_t_10; goto __pyx_L6_bool_binop_done; } - __pyx_t_10 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_real1, Py_NE)); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(2, 724, __pyx_L1_error) + __pyx_t_10 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_real1, Py_NE)); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(2, 722, __pyx_L1_error) __pyx_t_9 = __pyx_t_10; __pyx_L6_bool_binop_done:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -49732,8 +48841,8 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_360_ta_getOutputParameterInfo(CYTHON_U __pyx_L4_bool_binop_done:; if (__pyx_t_8) { - __pyx_t_7 = __Pyx_PyUnicode_GET_LENGTH(__pyx_mstate_global->__pyx_n_u_real); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(2, 725, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyObject_GetSlice(__pyx_v_name, __pyx_t_7, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 725, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_GET_LENGTH(__pyx_mstate_global->__pyx_n_u_real); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(2, 723, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetSlice(__pyx_v_name, __pyx_t_7, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 723, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_2); __pyx_t_2 = 0; @@ -49742,16 +48851,16 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_360_ta_getOutputParameterInfo(CYTHON_U __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 728, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 726, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_name, __pyx_v_name) < 0) __PYX_ERR(2, 728, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_name, __pyx_v_name) < (0)) __PYX_ERR(2, 726, __pyx_L1_error) __pyx_t_4 = NULL; - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 729, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 727, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_11 = __Pyx_PyLong_From_TA_OutputFlags(__pyx_v_info->flags); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 729, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyLong_From_TA_OutputFlags(__pyx_v_info->flags); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 727, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_TA_OUTPUT_FLAGS); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 729, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_TA_OUTPUT_FLAGS); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 727, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); __pyx_t_6 = 1; #if CYTHON_UNPACK_METHODS @@ -49767,15 +48876,15 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_360_ta_getOutputParameterInfo(CYTHON_U #endif { PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_11, __pyx_t_12}; - __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 729, __pyx_L1_error) + if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 727, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); } - if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_flags, __pyx_t_5) < 0) __PYX_ERR(2, 728, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_flags, __pyx_t_5) < (0)) __PYX_ERR(2, 726, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; @@ -49808,7 +48917,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_362_get_defaults_and_docs, "_get_defaults_and_docs(func_info)\nReturns a tuple with two outputs: defaults, a dict of parameter defaults,\nand documentation, a formatted docstring for the function.\n.. Note: func_info should come from Function.info, *not* _ta_getFuncInfo."); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_362_get_defaults_and_docs, "_get_defaults_and_docs(func_info)\n\nReturns a tuple with two outputs: defaults, a dict of parameter defaults,\nand documentation, a formatted docstring for the function.\n.. Note: func_info should come from Function.info, *not* _ta_getFuncInfo."); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_363_get_defaults_and_docs = {"_get_defaults_and_docs", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_363_get_defaults_and_docs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_362_get_defaults_and_docs}; static PyObject *__pyx_pw_5talib_7_ta_lib_363_get_defaults_and_docs(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -49840,32 +48949,32 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_func_info,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 732, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 730, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); - if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 732, __pyx_L3_error) + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 730, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_get_defaults_and_docs", 0) < 0) __PYX_ERR(2, 732, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_get_defaults_and_docs", 0) < (0)) __PYX_ERR(2, 730, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { - if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_get_defaults_and_docs", 1, 1, 1, i); __PYX_ERR(2, 732, __pyx_L3_error) } + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_get_defaults_and_docs", 1, 1, 1, i); __PYX_ERR(2, 730, __pyx_L3_error) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); - if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 732, __pyx_L3_error) + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 730, __pyx_L3_error) } __pyx_v_func_info = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("_get_defaults_and_docs", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 732, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_get_defaults_and_docs", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 730, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -49918,57 +49027,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_362_get_defaults_and_docs(CYTHON_UNUSE int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_get_defaults_and_docs", 0); - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 738, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 736, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_defaults = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_func_info, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 739, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_func_info, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 737, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 739, __pyx_L1_error) + __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 737, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_t_1) != (0)) __PYX_ERR(2, 739, __pyx_L1_error); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_t_1) != (0)) __PYX_ERR(2, 737, __pyx_L1_error); __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u__6); __Pyx_GIVEREF(__pyx_mstate_global->__pyx_kp_u__6); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 1, __pyx_mstate_global->__pyx_kp_u__6) != (0)) __PYX_ERR(2, 739, __pyx_L1_error); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 1, __pyx_mstate_global->__pyx_kp_u__6) != (0)) __PYX_ERR(2, 737, __pyx_L1_error); __pyx_t_1 = 0; __pyx_v_func_line = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 740, __pyx_L1_error) + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 738, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_input_arrays_2); __Pyx_GIVEREF(__pyx_mstate_global->__pyx_kp_u_input_arrays_2); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_mstate_global->__pyx_kp_u_input_arrays_2) != (0)) __PYX_ERR(2, 740, __pyx_L1_error); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_mstate_global->__pyx_kp_u_input_arrays_2) != (0)) __PYX_ERR(2, 738, __pyx_L1_error); __pyx_v_func_args = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 741, __pyx_L1_error) + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 739, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_docs = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyUnicode_FormatSafe(__pyx_mstate_global->__pyx_kp_u_display_name_s_group_s, __pyx_v_func_info); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 742, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyUnicode_FormatSafe(__pyx_mstate_global->__pyx_kp_u_display_name_s_group_s, __pyx_v_func_info); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 740, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 742, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 740, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_func_info, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 744, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_func_info, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 742, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_input_names = __pyx_t_2; __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_mstate_global->__pyx_kp_u_Inputs); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 745, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_mstate_global->__pyx_kp_u_Inputs); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 743, __pyx_L1_error) if (likely(PyList_CheckExact(__pyx_v_input_names)) || PyTuple_CheckExact(__pyx_v_input_names)) { __pyx_t_2 = __pyx_v_input_names; __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0; __pyx_t_5 = NULL; } else { - __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_input_names); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 746, __pyx_L1_error) + __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_input_names); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 744, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 746, __pyx_L1_error) + __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 744, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_5)) { @@ -49976,17 +49085,17 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_362_get_defaults_and_docs(CYTHON_UNUSE { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_SIZE - if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 746, __pyx_L1_error) + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 744, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } - __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_4); + __pyx_t_1 = __Pyx_PyList_GetItemRefFast(__pyx_t_2, __pyx_t_4, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_4; } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_SIZE - if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 746, __pyx_L1_error) + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 744, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } @@ -49997,13 +49106,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_362_get_defaults_and_docs(CYTHON_UNUSE #endif ++__pyx_t_4; } - if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 746, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 744, __pyx_L1_error) } else { __pyx_t_1 = __pyx_t_5(__pyx_t_2); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 746, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 744, __pyx_L1_error) PyErr_Clear(); } break; @@ -50013,7 +49122,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_362_get_defaults_and_docs(CYTHON_UNUSE __Pyx_XDECREF_SET(__pyx_v_input_name, __pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_input_names, __pyx_v_input_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 747, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_input_names, __pyx_v_input_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_1); __pyx_t_1 = 0; @@ -50027,34 +49136,34 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_362_get_defaults_and_docs(CYTHON_UNUSE } - __pyx_t_1 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_input_name), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 750, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_input_name), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_8 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_value), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 750, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_value), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9[0] = __pyx_mstate_global->__pyx_kp_u__7; __pyx_t_9[1] = __pyx_t_1; __pyx_t_9[2] = __pyx_mstate_global->__pyx_kp_u_; __pyx_t_9[3] = __pyx_t_8; __pyx_t_10 = __Pyx_PyUnicode_Join(__pyx_t_9, 4, 4 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8)); - if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 750, __pyx_L1_error) + if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_t_10); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 750, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_t_10); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 748, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_func_info, __pyx_mstate_global->__pyx_n_u_parameters); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 752, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_func_info, __pyx_mstate_global->__pyx_n_u_parameters); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 750, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_params = __pyx_t_2; __pyx_t_2 = 0; - __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_params); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 753, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_params); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 751, __pyx_L1_error) if (__pyx_t_7) { - __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_mstate_global->__pyx_kp_u_Parameters); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 754, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_mstate_global->__pyx_kp_u_Parameters); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 752, __pyx_L1_error) } @@ -50063,9 +49172,9 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_362_get_defaults_and_docs(CYTHON_UNUSE __pyx_t_4 = 0; __pyx_t_5 = NULL; } else { - __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_params); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 755, __pyx_L1_error) + __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_params); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 753, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 755, __pyx_L1_error) + __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 753, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_5)) { @@ -50073,17 +49182,17 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_362_get_defaults_and_docs(CYTHON_UNUSE { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_SIZE - if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 755, __pyx_L1_error) + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 753, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } - __pyx_t_10 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_4); + __pyx_t_10 = __Pyx_PyList_GetItemRefFast(__pyx_t_2, __pyx_t_4, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_4; } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_SIZE - if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 755, __pyx_L1_error) + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 753, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } @@ -50094,13 +49203,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_362_get_defaults_and_docs(CYTHON_UNUSE #endif ++__pyx_t_4; } - if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 755, __pyx_L1_error) + if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 753, __pyx_L1_error) } else { __pyx_t_10 = __pyx_t_5(__pyx_t_2); if (unlikely(!__pyx_t_10)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 755, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 753, __pyx_L1_error) PyErr_Clear(); } break; @@ -50110,11 +49219,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_362_get_defaults_and_docs(CYTHON_UNUSE __Pyx_XDECREF_SET(__pyx_v_param, __pyx_t_10); __pyx_t_10 = 0; - __pyx_t_10 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_param), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 756, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_param), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 754, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_v_params, __pyx_v_param); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 756, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_v_params, __pyx_v_param); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 754, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_1 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_t_8), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 756, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_t_8), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 754, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_9[0] = __pyx_mstate_global->__pyx_kp_u__7; @@ -50122,18 +49231,18 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_362_get_defaults_and_docs(CYTHON_UNUSE __pyx_t_9[2] = __pyx_mstate_global->__pyx_kp_u_; __pyx_t_9[3] = __pyx_t_1; __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_9, 4, 4 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_10) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1)); - if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 756, __pyx_L1_error) + if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 754, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_t_8); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 756, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_t_8); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 754, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_param), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 757, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_param), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 755, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_params, __pyx_v_param); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 757, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_params, __pyx_v_param); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 755, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_10 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_t_1), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 757, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_t_1), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 755, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_11[0] = __pyx_mstate_global->__pyx_kp_u__8; @@ -50142,46 +49251,46 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_362_get_defaults_and_docs(CYTHON_UNUSE __pyx_t_11[3] = __pyx_t_10; __pyx_t_11[4] = __pyx_mstate_global->__pyx_kp_u__10; __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_11, 5, 1 * 3 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_10)); - if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 757, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 755, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_func_args, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 757, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_func_args, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 755, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_params, __pyx_v_param); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 758, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_params, __pyx_v_param); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 756, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (unlikely((PyDict_SetItem(__pyx_v_defaults, __pyx_v_param, __pyx_t_1) < 0))) __PYX_ERR(2, 758, __pyx_L1_error) + if (unlikely((PyDict_SetItem(__pyx_v_defaults, __pyx_v_param, __pyx_t_1) < 0))) __PYX_ERR(2, 756, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_v_param, __pyx_mstate_global->__pyx_n_u_matype, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 759, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_v_param, __pyx_mstate_global->__pyx_n_u_matype, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 757, __pyx_L1_error) if (__pyx_t_7) { - __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_docs, -1L, long, 1, __Pyx_PyLong_From_long, 1, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 760, __pyx_L1_error) + __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_docs, -1L, long, 1, __Pyx_PyLong_From_long, 1, 1, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 758, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 760, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 758, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_v_params, __pyx_v_param); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 760, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_v_params, __pyx_v_param); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 758, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_12 = __Pyx_PyObject_GetItem(__pyx_t_10, __pyx_t_8); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 760, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyObject_GetItem(__pyx_t_10, __pyx_t_8); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 758, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyUnicode_FormatSafe(__pyx_mstate_global->__pyx_kp_u_s_3, __pyx_t_12); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 760, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_FormatSafe(__pyx_mstate_global->__pyx_kp_u_s_3, __pyx_t_12); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 758, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - __pyx_t_12 = PyList_New(2); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 760, __pyx_L1_error) + __pyx_t_12 = PyList_New(2); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 758, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyList_SET_ITEM(__pyx_t_12, 0, __pyx_t_1) != (0)) __PYX_ERR(2, 760, __pyx_L1_error); + if (__Pyx_PyList_SET_ITEM(__pyx_t_12, 0, __pyx_t_1) != (0)) __PYX_ERR(2, 758, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_8); - if (__Pyx_PyList_SET_ITEM(__pyx_t_12, 1, __pyx_t_8) != (0)) __PYX_ERR(2, 760, __pyx_L1_error); + if (__Pyx_PyList_SET_ITEM(__pyx_t_12, 1, __pyx_t_8) != (0)) __PYX_ERR(2, 758, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_8 = 0; - __pyx_t_8 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__11, __pyx_t_12); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 760, __pyx_L1_error) + __pyx_t_8 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__11, __pyx_t_12); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 758, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - if (unlikely((__Pyx_SetItemInt(__pyx_v_docs, -1L, __pyx_t_8, long, 1, __Pyx_PyLong_From_long, 1, 1, 1) < 0))) __PYX_ERR(2, 760, __pyx_L1_error) + if (unlikely((__Pyx_SetItemInt(__pyx_v_docs, -1L, __pyx_t_8, long, 1, __Pyx_PyLong_From_long, 1, 1, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference) < 0))) __PYX_ERR(2, 758, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } @@ -50189,21 +49298,21 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_362_get_defaults_and_docs(CYTHON_UNUSE } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_func_info, __pyx_mstate_global->__pyx_n_u_output_names); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 762, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_func_info, __pyx_mstate_global->__pyx_n_u_output_names); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 760, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_outputs = __pyx_t_2; __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_mstate_global->__pyx_kp_u_Outputs); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 763, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_mstate_global->__pyx_kp_u_Outputs); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 761, __pyx_L1_error) if (likely(PyList_CheckExact(__pyx_v_outputs)) || PyTuple_CheckExact(__pyx_v_outputs)) { __pyx_t_2 = __pyx_v_outputs; __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0; __pyx_t_5 = NULL; } else { - __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_outputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 764, __pyx_L1_error) + __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_outputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 762, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 764, __pyx_L1_error) + __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 762, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_5)) { @@ -50211,17 +49320,17 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_362_get_defaults_and_docs(CYTHON_UNUSE { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_SIZE - if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 764, __pyx_L1_error) + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 762, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } - __pyx_t_8 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_4); + __pyx_t_8 = __Pyx_PyList_GetItemRefFast(__pyx_t_2, __pyx_t_4, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_4; } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_SIZE - if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 764, __pyx_L1_error) + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 762, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } @@ -50232,13 +49341,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_362_get_defaults_and_docs(CYTHON_UNUSE #endif ++__pyx_t_4; } - if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 764, __pyx_L1_error) + if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 762, __pyx_L1_error) } else { __pyx_t_8 = __pyx_t_5(__pyx_t_2); if (unlikely(!__pyx_t_8)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { - if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 764, __pyx_L1_error) + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 762, __pyx_L1_error) PyErr_Clear(); } break; @@ -50248,7 +49357,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_362_get_defaults_and_docs(CYTHON_UNUSE __Pyx_XDECREF_SET(__pyx_v_output, __pyx_t_8); __pyx_t_8 = 0; - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_v_output, __pyx_mstate_global->__pyx_n_u_integer, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 765, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_v_output, __pyx_mstate_global->__pyx_n_u_integer, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 763, __pyx_L1_error) if (__pyx_t_7) { __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_integer_values_are_100_0_or_100); @@ -50256,40 +49365,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_362_get_defaults_and_docs(CYTHON_UNUSE } - __pyx_t_8 = __Pyx_PyUnicode_FormatSafe(__pyx_mstate_global->__pyx_kp_u_s_4, __pyx_v_output); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 767, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_FormatSafe(__pyx_mstate_global->__pyx_kp_u_s_4, __pyx_v_output); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 765, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_t_8); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 767, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_t_8); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 765, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__3, __pyx_v_func_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 769, __pyx_L1_error) + __pyx_t_2 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__3, __pyx_v_func_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 767, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_func_line, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 769, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_func_line, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 767, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_func_line, __pyx_mstate_global->__pyx_kp_u__12); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 770, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_func_line, __pyx_mstate_global->__pyx_kp_u__12); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 768, __pyx_L1_error) - __pyx_t_2 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__2, __pyx_v_func_line); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 771, __pyx_L1_error) + __pyx_t_2 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__2, __pyx_v_func_line); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 769, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyList_Insert(__pyx_v_docs, 0, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 771, __pyx_L1_error) + __pyx_t_3 = PyList_Insert(__pyx_v_docs, 0, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 769, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__13, __pyx_v_docs); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 772, __pyx_L1_error) + __pyx_t_2 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__13, __pyx_v_docs); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 770, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_documentation = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 773, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 771, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_defaults); __Pyx_GIVEREF(__pyx_v_defaults); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_defaults) != (0)) __PYX_ERR(2, 773, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_defaults) != (0)) __PYX_ERR(2, 771, __pyx_L1_error); __Pyx_INCREF(__pyx_v_documentation); __Pyx_GIVEREF(__pyx_v_documentation); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_documentation) != (0)) __PYX_ERR(2, 773, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_documentation) != (0)) __PYX_ERR(2, 771, __pyx_L1_error); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; @@ -50333,7 +49442,7 @@ static TA_FuncHandle const *__pyx_f_5talib_7_ta_lib___ta_getFuncHandle(char *__p int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__ta_getFuncHandle", 0); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GetFuncHandle, TA_GetFuncHandle(__pyx_v_function_name, (&__pyx_v_handle)), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 789, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GetFuncHandle, TA_GetFuncHandle(__pyx_v_function_name, (&__pyx_v_handle)), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 787, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -50345,7 +49454,7 @@ static TA_FuncHandle const *__pyx_f_5talib_7_ta_lib___ta_getFuncHandle(char *__p __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("talib._ta_lib.__ta_getFuncHandle", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; + __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -50364,10 +49473,10 @@ static TA_ParamHolder *__pyx_f_5talib_7_ta_lib___ta_paramHolderAlloc(char *__pyx int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__ta_paramHolderAlloc", 0); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name); if (unlikely(__pyx_t_1 == ((TA_FuncHandle const *)0) && PyErr_Occurred())) __PYX_ERR(2, 797, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name); if (unlikely(__pyx_t_1 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(2, 795, __pyx_L1_error) __pyx_v_retCode = TA_ParamHolderAlloc(__pyx_t_1, (&__pyx_v_holder)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ParamHolderAlloc, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 798, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ParamHolderAlloc, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 796, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -50379,7 +49488,7 @@ static TA_ParamHolder *__pyx_f_5talib_7_ta_lib___ta_paramHolderAlloc(char *__pyx __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("talib._ta_lib.__ta_paramHolderAlloc", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; + __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -50395,7 +49504,7 @@ static int __pyx_f_5talib_7_ta_lib___ta_paramHolderFree(TA_ParamHolder *__pyx_v_ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__ta_paramHolderFree", 0); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ParamHolderFree, TA_ParamHolderFree(__pyx_v_params), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 806, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ParamHolderFree, TA_ParamHolderFree(__pyx_v_params), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 804, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -50425,7 +49534,7 @@ static int __pyx_f_5talib_7_ta_lib___ta_setOptInputParamInteger(TA_ParamHolder * __pyx_v_retCode = TA_SetOptInputParamInteger(__pyx_v_holder, __pyx_v_idx, __pyx_v_value); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SetOptInputParamInteger, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 810, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SetOptInputParamInteger, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 808, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -50455,7 +49564,7 @@ static int __pyx_f_5talib_7_ta_lib___ta_setOptInputParamReal(TA_ParamHolder *__p __pyx_v_retCode = TA_SetOptInputParamReal(__pyx_v_holder, __pyx_v_idx, __pyx_v_value); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SetOptInputParamReal, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 814, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SetOptInputParamReal, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 812, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -50486,7 +49595,7 @@ static int __pyx_f_5talib_7_ta_lib___ta_getLookback(TA_ParamHolder *__pyx_v_hold __pyx_v_retCode = TA_GetLookback(__pyx_v_holder, (&__pyx_v_lookback)); - __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GetLookback, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 819, __pyx_L1_error) + __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GetLookback, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 817, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -50513,7 +49622,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_364stream_ACCBANDS, "stream_ACCBANDS(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\nACCBANDS(high, low, close[, timeperiod=?])\n\nAcceleration Bands (Overlap Studies)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 20\nOutputs:\n upperband\n middleband\n lowerband"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_364stream_ACCBANDS, "stream_ACCBANDS(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nACCBANDS(high, low, close[, timeperiod=?])\n\nAcceleration Bands (Overlap Studies)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 20\nOutputs:\n upperband\n middleband\n lowerband"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_365stream_ACCBANDS = {"stream_ACCBANDS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_365stream_ACCBANDS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_364stream_ACCBANDS}; static PyObject *__pyx_pw_5talib_7_ta_lib_365stream_ACCBANDS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -50548,7 +49657,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 9, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 9, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -50571,7 +49680,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ACCBANDS", 0) < 0) __PYX_ERR(5, 9, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ACCBANDS", 0) < (0)) __PYX_ERR(5, 9, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ACCBANDS", 0, 3, 4, i); __PYX_ERR(5, 9, __pyx_L3_error) } } @@ -50683,7 +49792,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_364stream_ACCBANDS(CYTHON_UNUSED PyObj __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 42, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 42, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outrealupperband = __pyx_v_5talib_7_ta_lib_NaN; @@ -50747,7 +49856,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_366stream_ACOS, "stream_ACOS(ndarray real)\nACOS(real)\n\nVector Trigonometric ACos (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_366stream_ACOS, "stream_ACOS(ndarray real)\n\nACOS(real)\n\nVector Trigonometric ACos (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_367stream_ACOS = {"stream_ACOS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_367stream_ACOS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_366stream_ACOS}; static PyObject *__pyx_pw_5talib_7_ta_lib_367stream_ACOS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -50779,7 +49888,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 50, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 50, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -50790,7 +49899,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ACOS", 0) < 0) __PYX_ERR(5, 50, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ACOS", 0) < (0)) __PYX_ERR(5, 50, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ACOS", 1, 1, 1, i); __PYX_ERR(5, 50, __pyx_L3_error) } } @@ -50897,7 +50006,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_368stream_AD, "stream_AD(ndarray high, ndarray low, ndarray close, ndarray volume)\nAD(high, low, close, volume)\n\nChaikin A/D Line (Volume Indicators)\n\nInputs:\n prices: ['high', 'low', 'close', 'volume']\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_368stream_AD, "stream_AD(ndarray high, ndarray low, ndarray close, ndarray volume)\n\nAD(high, low, close, volume)\n\nChaikin A/D Line (Volume Indicators)\n\nInputs:\n prices: ['high', 'low', 'close', 'volume']\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_369stream_AD = {"stream_AD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_369stream_AD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_368stream_AD}; static PyObject *__pyx_pw_5talib_7_ta_lib_369stream_AD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -50932,7 +50041,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_volume,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 77, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 77, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -50955,7 +50064,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_AD", 0) < 0) __PYX_ERR(5, 77, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_AD", 0) < (0)) __PYX_ERR(5, 77, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_AD", 1, 4, 4, i); __PYX_ERR(5, 77, __pyx_L3_error) } } @@ -51063,7 +50172,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_368stream_AD(CYTHON_UNUSED PyObject *_ __pyx_v_volume_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 107, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 107, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -51106,7 +50215,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_370stream_ADD, "stream_ADD(ndarray real0, ndarray real1)\nADD(real0, real1)\n\nVector Arithmetic Add (Math Operators)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_370stream_ADD, "stream_ADD(ndarray real0, ndarray real1)\n\nADD(real0, real1)\n\nVector Arithmetic Add (Math Operators)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_371stream_ADD = {"stream_ADD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_371stream_ADD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_370stream_ADD}; static PyObject *__pyx_pw_5talib_7_ta_lib_371stream_ADD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -51139,7 +50248,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 113, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 113, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -51154,7 +50263,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ADD", 0) < 0) __PYX_ERR(5, 113, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ADD", 0) < (0)) __PYX_ERR(5, 113, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ADD", 1, 2, 2, i); __PYX_ERR(5, 113, __pyx_L3_error) } } @@ -51236,7 +50345,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_370stream_ADD(CYTHON_UNUSED PyObject * __pyx_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 138, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 138, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -51277,7 +50386,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_372stream_ADOSC, "stream_ADOSC(ndarray high, ndarray low, ndarray close, ndarray volume, int fastperiod=-0x80000000, int slowperiod=-0x80000000)\nADOSC(high, low, close, volume[, fastperiod=?, slowperiod=?])\n\nChaikin A/D Oscillator (Volume Indicators)\n\nInputs:\n prices: ['high', 'low', 'close', 'volume']\nParameters:\n fastperiod: 3\n slowperiod: 10\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_372stream_ADOSC, "stream_ADOSC(ndarray high, ndarray low, ndarray close, ndarray volume, int fastperiod=-0x80000000, int slowperiod=-0x80000000)\n\nADOSC(high, low, close, volume[, fastperiod=?, slowperiod=?])\n\nChaikin A/D Oscillator (Volume Indicators)\n\nInputs:\n prices: ['high', 'low', 'close', 'volume']\nParameters:\n fastperiod: 3\n slowperiod: 10\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_373stream_ADOSC = {"stream_ADOSC", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_373stream_ADOSC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_372stream_ADOSC}; static PyObject *__pyx_pw_5talib_7_ta_lib_373stream_ADOSC(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -51314,7 +50423,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_volume,&__pyx_mstate_global->__pyx_n_u_fastperiod,&__pyx_mstate_global->__pyx_n_u_slowperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 144, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 144, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 6: @@ -51345,7 +50454,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ADOSC", 0) < 0) __PYX_ERR(5, 144, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ADOSC", 0) < (0)) __PYX_ERR(5, 144, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ADOSC", 0, 4, 6, i); __PYX_ERR(5, 144, __pyx_L3_error) } } @@ -51474,7 +50583,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_372stream_ADOSC(CYTHON_UNUSED PyObject __pyx_v_volume_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 177, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 177, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -51517,7 +50626,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_374stream_ADX, "stream_ADX(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\nADX(high, low, close[, timeperiod=?])\n\nAverage Directional Movement Index (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_374stream_ADX, "stream_ADX(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nADX(high, low, close[, timeperiod=?])\n\nAverage Directional Movement Index (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_375stream_ADX = {"stream_ADX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_375stream_ADX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_374stream_ADX}; static PyObject *__pyx_pw_5talib_7_ta_lib_375stream_ADX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -51552,7 +50661,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 183, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 183, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -51575,7 +50684,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ADX", 0) < 0) __PYX_ERR(5, 183, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ADX", 0) < (0)) __PYX_ERR(5, 183, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ADX", 0, 3, 4, i); __PYX_ERR(5, 183, __pyx_L3_error) } } @@ -51682,7 +50791,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_374stream_ADX(CYTHON_UNUSED PyObject * __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 212, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 212, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -51724,7 +50833,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_376stream_ADXR, "stream_ADXR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\nADXR(high, low, close[, timeperiod=?])\n\nAverage Directional Movement Index Rating (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_376stream_ADXR, "stream_ADXR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nADXR(high, low, close[, timeperiod=?])\n\nAverage Directional Movement Index Rating (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_377stream_ADXR = {"stream_ADXR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_377stream_ADXR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_376stream_ADXR}; static PyObject *__pyx_pw_5talib_7_ta_lib_377stream_ADXR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -51759,7 +50868,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 218, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 218, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -51782,7 +50891,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ADXR", 0) < 0) __PYX_ERR(5, 218, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ADXR", 0) < (0)) __PYX_ERR(5, 218, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ADXR", 0, 3, 4, i); __PYX_ERR(5, 218, __pyx_L3_error) } } @@ -51889,7 +50998,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_376stream_ADXR(CYTHON_UNUSED PyObject __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 247, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 247, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -51931,7 +51040,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_378stream_APO, "stream_APO(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int matype=0)\nAPO(real[, fastperiod=?, slowperiod=?, matype=?])\n\nAbsolute Price Oscillator (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n fastperiod: 12\n slowperiod: 26\n matype: 0 (Simple Moving Average)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_378stream_APO, "stream_APO(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int matype=0)\n\nAPO(real[, fastperiod=?, slowperiod=?, matype=?])\n\nAbsolute Price Oscillator (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n fastperiod: 12\n slowperiod: 26\n matype: 0 (Simple Moving Average)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_379stream_APO = {"stream_APO", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_379stream_APO, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_378stream_APO}; static PyObject *__pyx_pw_5talib_7_ta_lib_379stream_APO(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -51966,7 +51075,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_fastperiod,&__pyx_mstate_global->__pyx_n_u_slowperiod,&__pyx_mstate_global->__pyx_n_u_matype,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 253, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 253, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -51989,7 +51098,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_APO", 0) < 0) __PYX_ERR(5, 253, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_APO", 0) < (0)) __PYX_ERR(5, 253, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_APO", 0, 1, 4, i); __PYX_ERR(5, 253, __pyx_L3_error) } } @@ -52126,7 +51235,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_380stream_AROON, "stream_AROON(ndarray high, ndarray low, int timeperiod=-0x80000000)\nAROON(high, low[, timeperiod=?])\n\nAroon (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n timeperiod: 14\nOutputs:\n aroondown\n aroonup"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_380stream_AROON, "stream_AROON(ndarray high, ndarray low, int timeperiod=-0x80000000)\n\nAROON(high, low[, timeperiod=?])\n\nAroon (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n timeperiod: 14\nOutputs:\n aroondown\n aroonup"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_381stream_AROON = {"stream_AROON", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_381stream_AROON, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_380stream_AROON}; static PyObject *__pyx_pw_5talib_7_ta_lib_381stream_AROON(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -52160,7 +51269,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 284, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 284, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -52179,7 +51288,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_AROON", 0) < 0) __PYX_ERR(5, 284, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_AROON", 0) < (0)) __PYX_ERR(5, 284, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_AROON", 0, 2, 3, i); __PYX_ERR(5, 284, __pyx_L3_error) } } @@ -52276,7 +51385,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_380stream_AROON(CYTHON_UNUSED PyObject __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 312, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 312, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outaroondown = __pyx_v_5talib_7_ta_lib_NaN; @@ -52331,7 +51440,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_382stream_AROONOSC, "stream_AROONOSC(ndarray high, ndarray low, int timeperiod=-0x80000000)\nAROONOSC(high, low[, timeperiod=?])\n\nAroon Oscillator (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_382stream_AROONOSC, "stream_AROONOSC(ndarray high, ndarray low, int timeperiod=-0x80000000)\n\nAROONOSC(high, low[, timeperiod=?])\n\nAroon Oscillator (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_383stream_AROONOSC = {"stream_AROONOSC", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_383stream_AROONOSC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_382stream_AROONOSC}; static PyObject *__pyx_pw_5talib_7_ta_lib_383stream_AROONOSC(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -52365,7 +51474,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 319, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 319, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -52384,7 +51493,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_AROONOSC", 0) < 0) __PYX_ERR(5, 319, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_AROONOSC", 0) < (0)) __PYX_ERR(5, 319, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_AROONOSC", 0, 2, 3, i); __PYX_ERR(5, 319, __pyx_L3_error) } } @@ -52478,7 +51587,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_382stream_AROONOSC(CYTHON_UNUSED PyObj __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 345, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 345, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -52519,7 +51628,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_384stream_ASIN, "stream_ASIN(ndarray real)\nASIN(real)\n\nVector Trigonometric ASin (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_384stream_ASIN, "stream_ASIN(ndarray real)\n\nASIN(real)\n\nVector Trigonometric ASin (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_385stream_ASIN = {"stream_ASIN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_385stream_ASIN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_384stream_ASIN}; static PyObject *__pyx_pw_5talib_7_ta_lib_385stream_ASIN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -52551,7 +51660,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 351, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 351, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -52562,7 +51671,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ASIN", 0) < 0) __PYX_ERR(5, 351, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ASIN", 0) < (0)) __PYX_ERR(5, 351, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ASIN", 1, 1, 1, i); __PYX_ERR(5, 351, __pyx_L3_error) } } @@ -52669,7 +51778,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_386stream_ATAN, "stream_ATAN(ndarray real)\nATAN(real)\n\nVector Trigonometric ATan (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_386stream_ATAN, "stream_ATAN(ndarray real)\n\nATAN(real)\n\nVector Trigonometric ATan (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_387stream_ATAN = {"stream_ATAN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_387stream_ATAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_386stream_ATAN}; static PyObject *__pyx_pw_5talib_7_ta_lib_387stream_ATAN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -52701,7 +51810,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 378, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 378, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -52712,7 +51821,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ATAN", 0) < 0) __PYX_ERR(5, 378, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ATAN", 0) < (0)) __PYX_ERR(5, 378, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ATAN", 1, 1, 1, i); __PYX_ERR(5, 378, __pyx_L3_error) } } @@ -52819,7 +51928,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_388stream_ATR, "stream_ATR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\nATR(high, low, close[, timeperiod=?])\n\nAverage True Range (Volatility Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_388stream_ATR, "stream_ATR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nATR(high, low, close[, timeperiod=?])\n\nAverage True Range (Volatility Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_389stream_ATR = {"stream_ATR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_389stream_ATR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_388stream_ATR}; static PyObject *__pyx_pw_5talib_7_ta_lib_389stream_ATR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -52854,7 +51963,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 405, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 405, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -52877,7 +51986,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ATR", 0) < 0) __PYX_ERR(5, 405, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ATR", 0) < (0)) __PYX_ERR(5, 405, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ATR", 0, 3, 4, i); __PYX_ERR(5, 405, __pyx_L3_error) } } @@ -52984,7 +52093,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_388stream_ATR(CYTHON_UNUSED PyObject * __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 434, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 434, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -53026,7 +52135,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_390stream_AVGPRICE, "stream_AVGPRICE(ndarray open, ndarray high, ndarray low, ndarray close)\nAVGPRICE(open, high, low, close)\n\nAverage Price (Price Transform)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_390stream_AVGPRICE, "stream_AVGPRICE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nAVGPRICE(open, high, low, close)\n\nAverage Price (Price Transform)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_391stream_AVGPRICE = {"stream_AVGPRICE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_391stream_AVGPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_390stream_AVGPRICE}; static PyObject *__pyx_pw_5talib_7_ta_lib_391stream_AVGPRICE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -53061,7 +52170,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 440, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 440, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -53084,7 +52193,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_AVGPRICE", 0) < 0) __PYX_ERR(5, 440, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_AVGPRICE", 0) < (0)) __PYX_ERR(5, 440, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_AVGPRICE", 1, 4, 4, i); __PYX_ERR(5, 440, __pyx_L3_error) } } @@ -53192,7 +52301,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_390stream_AVGPRICE(CYTHON_UNUSED PyObj __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 470, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 470, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -53235,7 +52344,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_392stream_AVGDEV, "stream_AVGDEV(ndarray real, int timeperiod=-0x80000000)\nAVGDEV(real[, timeperiod=?])\n\nAverage Deviation (Price Transform)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_392stream_AVGDEV, "stream_AVGDEV(ndarray real, int timeperiod=-0x80000000)\n\nAVGDEV(real[, timeperiod=?])\n\nAverage Deviation (Price Transform)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_393stream_AVGDEV = {"stream_AVGDEV", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_393stream_AVGDEV, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_392stream_AVGDEV}; static PyObject *__pyx_pw_5talib_7_ta_lib_393stream_AVGDEV(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -53268,7 +52377,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 476, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 476, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -53283,7 +52392,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_AVGDEV", 0) < 0) __PYX_ERR(5, 476, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_AVGDEV", 0) < (0)) __PYX_ERR(5, 476, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_AVGDEV", 0, 1, 2, i); __PYX_ERR(5, 476, __pyx_L3_error) } } @@ -53402,7 +52511,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_394stream_BBANDS, "stream_BBANDS(ndarray real, int timeperiod=-0x80000000, double nbdevup=-4e37, double nbdevdn=-4e37, int matype=0)\nBBANDS(real[, timeperiod=?, nbdevup=?, nbdevdn=?, matype=?])\n\nBollinger Bands (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 5\n nbdevup: 2.0\n nbdevdn: 2.0\n matype: 0 (Simple Moving Average)\nOutputs:\n upperband\n middleband\n lowerband"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_394stream_BBANDS, "stream_BBANDS(ndarray real, int timeperiod=-0x80000000, double nbdevup=-4e37, double nbdevdn=-4e37, int matype=0)\n\nBBANDS(real[, timeperiod=?, nbdevup=?, nbdevdn=?, matype=?])\n\nBollinger Bands (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 5\n nbdevup: 2.0\n nbdevdn: 2.0\n matype: 0 (Simple Moving Average)\nOutputs:\n upperband\n middleband\n lowerband"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_395stream_BBANDS = {"stream_BBANDS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_395stream_BBANDS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_394stream_BBANDS}; static PyObject *__pyx_pw_5talib_7_ta_lib_395stream_BBANDS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -53438,7 +52547,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_nbdevup,&__pyx_mstate_global->__pyx_n_u_nbdevdn,&__pyx_mstate_global->__pyx_n_u_matype,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 505, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 505, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 5: @@ -53465,7 +52574,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_BBANDS", 0) < 0) __PYX_ERR(5, 505, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_BBANDS", 0) < (0)) __PYX_ERR(5, 505, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_BBANDS", 0, 1, 5, i); __PYX_ERR(5, 505, __pyx_L3_error) } } @@ -53638,7 +52747,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_396stream_BETA, "stream_BETA(ndarray real0, ndarray real1, int timeperiod=-0x80000000)\nBETA(real0, real1[, timeperiod=?])\n\nBeta (Statistic Functions)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nParameters:\n timeperiod: 5\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_396stream_BETA, "stream_BETA(ndarray real0, ndarray real1, int timeperiod=-0x80000000)\n\nBETA(real0, real1[, timeperiod=?])\n\nBeta (Statistic Functions)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nParameters:\n timeperiod: 5\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_397stream_BETA = {"stream_BETA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_397stream_BETA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_396stream_BETA}; static PyObject *__pyx_pw_5talib_7_ta_lib_397stream_BETA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -53672,7 +52781,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 543, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 543, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -53691,7 +52800,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_BETA", 0) < 0) __PYX_ERR(5, 543, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_BETA", 0) < (0)) __PYX_ERR(5, 543, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_BETA", 0, 2, 3, i); __PYX_ERR(5, 543, __pyx_L3_error) } } @@ -53785,7 +52894,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_396stream_BETA(CYTHON_UNUSED PyObject __pyx_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 570, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 570, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -53826,7 +52935,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_398stream_BOP, "stream_BOP(ndarray open, ndarray high, ndarray low, ndarray close)\nBOP(open, high, low, close)\n\nBalance Of Power (Momentum Indicators)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_398stream_BOP, "stream_BOP(ndarray open, ndarray high, ndarray low, ndarray close)\n\nBOP(open, high, low, close)\n\nBalance Of Power (Momentum Indicators)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_399stream_BOP = {"stream_BOP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_399stream_BOP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_398stream_BOP}; static PyObject *__pyx_pw_5talib_7_ta_lib_399stream_BOP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -53861,7 +52970,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 576, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 576, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -53884,7 +52993,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_BOP", 0) < 0) __PYX_ERR(5, 576, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_BOP", 0) < (0)) __PYX_ERR(5, 576, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_BOP", 1, 4, 4, i); __PYX_ERR(5, 576, __pyx_L3_error) } } @@ -53992,7 +53101,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_398stream_BOP(CYTHON_UNUSED PyObject * __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 606, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 606, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -54035,7 +53144,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_400stream_CCI, "stream_CCI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\nCCI(high, low, close[, timeperiod=?])\n\nCommodity Channel Index (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_400stream_CCI, "stream_CCI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nCCI(high, low, close[, timeperiod=?])\n\nCommodity Channel Index (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_401stream_CCI = {"stream_CCI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_401stream_CCI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_400stream_CCI}; static PyObject *__pyx_pw_5talib_7_ta_lib_401stream_CCI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -54070,7 +53179,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 612, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 612, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -54093,7 +53202,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CCI", 0) < 0) __PYX_ERR(5, 612, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CCI", 0) < (0)) __PYX_ERR(5, 612, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CCI", 0, 3, 4, i); __PYX_ERR(5, 612, __pyx_L3_error) } } @@ -54200,7 +53309,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_400stream_CCI(CYTHON_UNUSED PyObject * __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 641, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 641, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -54242,7 +53351,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_402stream_CDL2CROWS, "stream_CDL2CROWS(ndarray open, ndarray high, ndarray low, ndarray close)\nCDL2CROWS(open, high, low, close)\n\nTwo Crows (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_402stream_CDL2CROWS, "stream_CDL2CROWS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL2CROWS(open, high, low, close)\n\nTwo Crows (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_403stream_CDL2CROWS = {"stream_CDL2CROWS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_403stream_CDL2CROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_402stream_CDL2CROWS}; static PyObject *__pyx_pw_5talib_7_ta_lib_403stream_CDL2CROWS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -54277,7 +53386,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 647, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 647, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -54300,7 +53409,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDL2CROWS", 0) < 0) __PYX_ERR(5, 647, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDL2CROWS", 0) < (0)) __PYX_ERR(5, 647, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDL2CROWS", 1, 4, 4, i); __PYX_ERR(5, 647, __pyx_L3_error) } } @@ -54408,7 +53517,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_402stream_CDL2CROWS(CYTHON_UNUSED PyOb __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 677, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 677, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -54451,7 +53560,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_404stream_CDL3BLACKCROWS, "stream_CDL3BLACKCROWS(ndarray open, ndarray high, ndarray low, ndarray close)\nCDL3BLACKCROWS(open, high, low, close)\n\nThree Black Crows (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_404stream_CDL3BLACKCROWS, "stream_CDL3BLACKCROWS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3BLACKCROWS(open, high, low, close)\n\nThree Black Crows (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_405stream_CDL3BLACKCROWS = {"stream_CDL3BLACKCROWS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_405stream_CDL3BLACKCROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_404stream_CDL3BLACKCROWS}; static PyObject *__pyx_pw_5talib_7_ta_lib_405stream_CDL3BLACKCROWS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -54486,7 +53595,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 683, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 683, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -54509,7 +53618,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDL3BLACKCROWS", 0) < 0) __PYX_ERR(5, 683, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDL3BLACKCROWS", 0) < (0)) __PYX_ERR(5, 683, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDL3BLACKCROWS", 1, 4, 4, i); __PYX_ERR(5, 683, __pyx_L3_error) } } @@ -54617,7 +53726,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_404stream_CDL3BLACKCROWS(CYTHON_UNUSED __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 713, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 713, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -54660,7 +53769,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_406stream_CDL3INSIDE, "stream_CDL3INSIDE(ndarray open, ndarray high, ndarray low, ndarray close)\nCDL3INSIDE(open, high, low, close)\n\nThree Inside Up/Down (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_406stream_CDL3INSIDE, "stream_CDL3INSIDE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3INSIDE(open, high, low, close)\n\nThree Inside Up/Down (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_407stream_CDL3INSIDE = {"stream_CDL3INSIDE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_407stream_CDL3INSIDE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_406stream_CDL3INSIDE}; static PyObject *__pyx_pw_5talib_7_ta_lib_407stream_CDL3INSIDE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -54695,7 +53804,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 719, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 719, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -54718,7 +53827,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDL3INSIDE", 0) < 0) __PYX_ERR(5, 719, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDL3INSIDE", 0) < (0)) __PYX_ERR(5, 719, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDL3INSIDE", 1, 4, 4, i); __PYX_ERR(5, 719, __pyx_L3_error) } } @@ -54826,7 +53935,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_406stream_CDL3INSIDE(CYTHON_UNUSED PyO __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 749, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 749, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -54869,7 +53978,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_408stream_CDL3LINESTRIKE, "stream_CDL3LINESTRIKE(ndarray open, ndarray high, ndarray low, ndarray close)\nCDL3LINESTRIKE(open, high, low, close)\n\nThree-Line Strike (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_408stream_CDL3LINESTRIKE, "stream_CDL3LINESTRIKE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3LINESTRIKE(open, high, low, close)\n\nThree-Line Strike (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_409stream_CDL3LINESTRIKE = {"stream_CDL3LINESTRIKE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_409stream_CDL3LINESTRIKE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_408stream_CDL3LINESTRIKE}; static PyObject *__pyx_pw_5talib_7_ta_lib_409stream_CDL3LINESTRIKE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -54904,7 +54013,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 755, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 755, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -54927,7 +54036,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDL3LINESTRIKE", 0) < 0) __PYX_ERR(5, 755, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDL3LINESTRIKE", 0) < (0)) __PYX_ERR(5, 755, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDL3LINESTRIKE", 1, 4, 4, i); __PYX_ERR(5, 755, __pyx_L3_error) } } @@ -55035,7 +54144,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_408stream_CDL3LINESTRIKE(CYTHON_UNUSED __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 785, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 785, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -55078,7 +54187,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_410stream_CDL3OUTSIDE, "stream_CDL3OUTSIDE(ndarray open, ndarray high, ndarray low, ndarray close)\nCDL3OUTSIDE(open, high, low, close)\n\nThree Outside Up/Down (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_410stream_CDL3OUTSIDE, "stream_CDL3OUTSIDE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3OUTSIDE(open, high, low, close)\n\nThree Outside Up/Down (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_411stream_CDL3OUTSIDE = {"stream_CDL3OUTSIDE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_411stream_CDL3OUTSIDE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_410stream_CDL3OUTSIDE}; static PyObject *__pyx_pw_5talib_7_ta_lib_411stream_CDL3OUTSIDE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -55113,7 +54222,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 791, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 791, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -55136,7 +54245,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDL3OUTSIDE", 0) < 0) __PYX_ERR(5, 791, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDL3OUTSIDE", 0) < (0)) __PYX_ERR(5, 791, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDL3OUTSIDE", 1, 4, 4, i); __PYX_ERR(5, 791, __pyx_L3_error) } } @@ -55244,7 +54353,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_410stream_CDL3OUTSIDE(CYTHON_UNUSED Py __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 821, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 821, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -55287,7 +54396,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_412stream_CDL3STARSINSOUTH, "stream_CDL3STARSINSOUTH(ndarray open, ndarray high, ndarray low, ndarray close)\nCDL3STARSINSOUTH(open, high, low, close)\n\nThree Stars In The South (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_412stream_CDL3STARSINSOUTH, "stream_CDL3STARSINSOUTH(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3STARSINSOUTH(open, high, low, close)\n\nThree Stars In The South (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_413stream_CDL3STARSINSOUTH = {"stream_CDL3STARSINSOUTH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_413stream_CDL3STARSINSOUTH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_412stream_CDL3STARSINSOUTH}; static PyObject *__pyx_pw_5talib_7_ta_lib_413stream_CDL3STARSINSOUTH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -55322,7 +54431,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 827, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 827, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -55345,7 +54454,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDL3STARSINSOUTH", 0) < 0) __PYX_ERR(5, 827, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDL3STARSINSOUTH", 0) < (0)) __PYX_ERR(5, 827, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDL3STARSINSOUTH", 1, 4, 4, i); __PYX_ERR(5, 827, __pyx_L3_error) } } @@ -55453,7 +54562,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_412stream_CDL3STARSINSOUTH(CYTHON_UNUS __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 857, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 857, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -55496,7 +54605,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_414stream_CDL3WHITESOLDIERS, "stream_CDL3WHITESOLDIERS(ndarray open, ndarray high, ndarray low, ndarray close)\nCDL3WHITESOLDIERS(open, high, low, close)\n\nThree Advancing White Soldiers (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_414stream_CDL3WHITESOLDIERS, "stream_CDL3WHITESOLDIERS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3WHITESOLDIERS(open, high, low, close)\n\nThree Advancing White Soldiers (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_415stream_CDL3WHITESOLDIERS = {"stream_CDL3WHITESOLDIERS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_415stream_CDL3WHITESOLDIERS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_414stream_CDL3WHITESOLDIERS}; static PyObject *__pyx_pw_5talib_7_ta_lib_415stream_CDL3WHITESOLDIERS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -55531,7 +54640,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 863, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 863, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -55554,7 +54663,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDL3WHITESOLDIERS", 0) < 0) __PYX_ERR(5, 863, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDL3WHITESOLDIERS", 0) < (0)) __PYX_ERR(5, 863, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDL3WHITESOLDIERS", 1, 4, 4, i); __PYX_ERR(5, 863, __pyx_L3_error) } } @@ -55662,7 +54771,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_414stream_CDL3WHITESOLDIERS(CYTHON_UNU __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 893, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 893, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -55705,7 +54814,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_416stream_CDLABANDONEDBABY, "stream_CDLABANDONEDBABY(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\nCDLABANDONEDBABY(open, high, low, close[, penetration=?])\n\nAbandoned Baby (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.3\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_416stream_CDLABANDONEDBABY, "stream_CDLABANDONEDBABY(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\n\nCDLABANDONEDBABY(open, high, low, close[, penetration=?])\n\nAbandoned Baby (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.3\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_417stream_CDLABANDONEDBABY = {"stream_CDLABANDONEDBABY", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_417stream_CDLABANDONEDBABY, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_416stream_CDLABANDONEDBABY}; static PyObject *__pyx_pw_5talib_7_ta_lib_417stream_CDLABANDONEDBABY(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -55741,7 +54850,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 899, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 899, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 5: @@ -55768,7 +54877,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLABANDONEDBABY", 0) < 0) __PYX_ERR(5, 899, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLABANDONEDBABY", 0) < (0)) __PYX_ERR(5, 899, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLABANDONEDBABY", 0, 4, 5, i); __PYX_ERR(5, 899, __pyx_L3_error) } } @@ -55888,7 +54997,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_416stream_CDLABANDONEDBABY(CYTHON_UNUS __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 931, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 931, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -55931,7 +55040,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_418stream_CDLADVANCEBLOCK, "stream_CDLADVANCEBLOCK(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLADVANCEBLOCK(open, high, low, close)\n\nAdvance Block (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_418stream_CDLADVANCEBLOCK, "stream_CDLADVANCEBLOCK(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLADVANCEBLOCK(open, high, low, close)\n\nAdvance Block (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_419stream_CDLADVANCEBLOCK = {"stream_CDLADVANCEBLOCK", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_419stream_CDLADVANCEBLOCK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_418stream_CDLADVANCEBLOCK}; static PyObject *__pyx_pw_5talib_7_ta_lib_419stream_CDLADVANCEBLOCK(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -55966,7 +55075,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 937, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 937, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -55989,7 +55098,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLADVANCEBLOCK", 0) < 0) __PYX_ERR(5, 937, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLADVANCEBLOCK", 0) < (0)) __PYX_ERR(5, 937, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLADVANCEBLOCK", 1, 4, 4, i); __PYX_ERR(5, 937, __pyx_L3_error) } } @@ -56097,7 +55206,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_418stream_CDLADVANCEBLOCK(CYTHON_UNUSE __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 967, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 967, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -56140,7 +55249,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_420stream_CDLBELTHOLD, "stream_CDLBELTHOLD(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLBELTHOLD(open, high, low, close)\n\nBelt-hold (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_420stream_CDLBELTHOLD, "stream_CDLBELTHOLD(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLBELTHOLD(open, high, low, close)\n\nBelt-hold (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_421stream_CDLBELTHOLD = {"stream_CDLBELTHOLD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_421stream_CDLBELTHOLD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_420stream_CDLBELTHOLD}; static PyObject *__pyx_pw_5talib_7_ta_lib_421stream_CDLBELTHOLD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -56175,7 +55284,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 973, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 973, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -56198,7 +55307,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLBELTHOLD", 0) < 0) __PYX_ERR(5, 973, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLBELTHOLD", 0) < (0)) __PYX_ERR(5, 973, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLBELTHOLD", 1, 4, 4, i); __PYX_ERR(5, 973, __pyx_L3_error) } } @@ -56306,7 +55415,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_420stream_CDLBELTHOLD(CYTHON_UNUSED Py __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1003, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1003, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -56349,7 +55458,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_422stream_CDLBREAKAWAY, "stream_CDLBREAKAWAY(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLBREAKAWAY(open, high, low, close)\n\nBreakaway (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_422stream_CDLBREAKAWAY, "stream_CDLBREAKAWAY(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLBREAKAWAY(open, high, low, close)\n\nBreakaway (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_423stream_CDLBREAKAWAY = {"stream_CDLBREAKAWAY", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_423stream_CDLBREAKAWAY, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_422stream_CDLBREAKAWAY}; static PyObject *__pyx_pw_5talib_7_ta_lib_423stream_CDLBREAKAWAY(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -56384,7 +55493,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1009, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1009, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -56407,7 +55516,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLBREAKAWAY", 0) < 0) __PYX_ERR(5, 1009, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLBREAKAWAY", 0) < (0)) __PYX_ERR(5, 1009, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLBREAKAWAY", 1, 4, 4, i); __PYX_ERR(5, 1009, __pyx_L3_error) } } @@ -56515,7 +55624,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_422stream_CDLBREAKAWAY(CYTHON_UNUSED P __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1039, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1039, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -56558,7 +55667,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_424stream_CDLCLOSINGMARUBOZU, "stream_CDLCLOSINGMARUBOZU(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLCLOSINGMARUBOZU(open, high, low, close)\n\nClosing Marubozu (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_424stream_CDLCLOSINGMARUBOZU, "stream_CDLCLOSINGMARUBOZU(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLCLOSINGMARUBOZU(open, high, low, close)\n\nClosing Marubozu (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_425stream_CDLCLOSINGMARUBOZU = {"stream_CDLCLOSINGMARUBOZU", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_425stream_CDLCLOSINGMARUBOZU, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_424stream_CDLCLOSINGMARUBOZU}; static PyObject *__pyx_pw_5talib_7_ta_lib_425stream_CDLCLOSINGMARUBOZU(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -56593,7 +55702,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1045, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1045, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -56616,7 +55725,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLCLOSINGMARUBOZU", 0) < 0) __PYX_ERR(5, 1045, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLCLOSINGMARUBOZU", 0) < (0)) __PYX_ERR(5, 1045, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLCLOSINGMARUBOZU", 1, 4, 4, i); __PYX_ERR(5, 1045, __pyx_L3_error) } } @@ -56724,7 +55833,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_424stream_CDLCLOSINGMARUBOZU(CYTHON_UN __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1075, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1075, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -56767,7 +55876,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_426stream_CDLCONCEALBABYSWALL, "stream_CDLCONCEALBABYSWALL(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLCONCEALBABYSWALL(open, high, low, close)\n\nConcealing Baby Swallow (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_426stream_CDLCONCEALBABYSWALL, "stream_CDLCONCEALBABYSWALL(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLCONCEALBABYSWALL(open, high, low, close)\n\nConcealing Baby Swallow (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_427stream_CDLCONCEALBABYSWALL = {"stream_CDLCONCEALBABYSWALL", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_427stream_CDLCONCEALBABYSWALL, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_426stream_CDLCONCEALBABYSWALL}; static PyObject *__pyx_pw_5talib_7_ta_lib_427stream_CDLCONCEALBABYSWALL(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -56802,7 +55911,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1081, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1081, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -56825,7 +55934,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLCONCEALBABYSWALL", 0) < 0) __PYX_ERR(5, 1081, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLCONCEALBABYSWALL", 0) < (0)) __PYX_ERR(5, 1081, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLCONCEALBABYSWALL", 1, 4, 4, i); __PYX_ERR(5, 1081, __pyx_L3_error) } } @@ -56933,7 +56042,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_426stream_CDLCONCEALBABYSWALL(CYTHON_U __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1111, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1111, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -56976,7 +56085,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_428stream_CDLCOUNTERATTACK, "stream_CDLCOUNTERATTACK(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLCOUNTERATTACK(open, high, low, close)\n\nCounterattack (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_428stream_CDLCOUNTERATTACK, "stream_CDLCOUNTERATTACK(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLCOUNTERATTACK(open, high, low, close)\n\nCounterattack (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_429stream_CDLCOUNTERATTACK = {"stream_CDLCOUNTERATTACK", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_429stream_CDLCOUNTERATTACK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_428stream_CDLCOUNTERATTACK}; static PyObject *__pyx_pw_5talib_7_ta_lib_429stream_CDLCOUNTERATTACK(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -57011,7 +56120,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1117, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1117, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -57034,7 +56143,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLCOUNTERATTACK", 0) < 0) __PYX_ERR(5, 1117, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLCOUNTERATTACK", 0) < (0)) __PYX_ERR(5, 1117, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLCOUNTERATTACK", 1, 4, 4, i); __PYX_ERR(5, 1117, __pyx_L3_error) } } @@ -57142,7 +56251,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_428stream_CDLCOUNTERATTACK(CYTHON_UNUS __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1147, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1147, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -57185,7 +56294,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_430stream_CDLDARKCLOUDCOVER, "stream_CDLDARKCLOUDCOVER(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.5)\nCDLDARKCLOUDCOVER(open, high, low, close[, penetration=?])\n\nDark Cloud Cover (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.5\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_430stream_CDLDARKCLOUDCOVER, "stream_CDLDARKCLOUDCOVER(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.5)\n\nCDLDARKCLOUDCOVER(open, high, low, close[, penetration=?])\n\nDark Cloud Cover (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.5\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_431stream_CDLDARKCLOUDCOVER = {"stream_CDLDARKCLOUDCOVER", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_431stream_CDLDARKCLOUDCOVER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_430stream_CDLDARKCLOUDCOVER}; static PyObject *__pyx_pw_5talib_7_ta_lib_431stream_CDLDARKCLOUDCOVER(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -57221,7 +56330,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1153, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1153, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 5: @@ -57248,7 +56357,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLDARKCLOUDCOVER", 0) < 0) __PYX_ERR(5, 1153, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLDARKCLOUDCOVER", 0) < (0)) __PYX_ERR(5, 1153, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLDARKCLOUDCOVER", 0, 4, 5, i); __PYX_ERR(5, 1153, __pyx_L3_error) } } @@ -57368,7 +56477,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_430stream_CDLDARKCLOUDCOVER(CYTHON_UNU __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1185, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1185, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -57411,7 +56520,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_432stream_CDLDOJI, "stream_CDLDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLDOJI(open, high, low, close)\n\nDoji (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_432stream_CDLDOJI, "stream_CDLDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLDOJI(open, high, low, close)\n\nDoji (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_433stream_CDLDOJI = {"stream_CDLDOJI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_433stream_CDLDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_432stream_CDLDOJI}; static PyObject *__pyx_pw_5talib_7_ta_lib_433stream_CDLDOJI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -57446,7 +56555,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1191, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1191, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -57469,7 +56578,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLDOJI", 0) < 0) __PYX_ERR(5, 1191, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLDOJI", 0) < (0)) __PYX_ERR(5, 1191, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLDOJI", 1, 4, 4, i); __PYX_ERR(5, 1191, __pyx_L3_error) } } @@ -57577,7 +56686,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_432stream_CDLDOJI(CYTHON_UNUSED PyObje __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1221, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1221, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -57620,7 +56729,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_434stream_CDLDOJISTAR, "stream_CDLDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLDOJISTAR(open, high, low, close)\n\nDoji Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_434stream_CDLDOJISTAR, "stream_CDLDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLDOJISTAR(open, high, low, close)\n\nDoji Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_435stream_CDLDOJISTAR = {"stream_CDLDOJISTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_435stream_CDLDOJISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_434stream_CDLDOJISTAR}; static PyObject *__pyx_pw_5talib_7_ta_lib_435stream_CDLDOJISTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -57655,7 +56764,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1227, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1227, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -57678,7 +56787,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLDOJISTAR", 0) < 0) __PYX_ERR(5, 1227, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLDOJISTAR", 0) < (0)) __PYX_ERR(5, 1227, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLDOJISTAR", 1, 4, 4, i); __PYX_ERR(5, 1227, __pyx_L3_error) } } @@ -57786,7 +56895,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_434stream_CDLDOJISTAR(CYTHON_UNUSED Py __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1257, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1257, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -57829,7 +56938,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_436stream_CDLDRAGONFLYDOJI, "stream_CDLDRAGONFLYDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLDRAGONFLYDOJI(open, high, low, close)\n\nDragonfly Doji (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_436stream_CDLDRAGONFLYDOJI, "stream_CDLDRAGONFLYDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLDRAGONFLYDOJI(open, high, low, close)\n\nDragonfly Doji (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_437stream_CDLDRAGONFLYDOJI = {"stream_CDLDRAGONFLYDOJI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_437stream_CDLDRAGONFLYDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_436stream_CDLDRAGONFLYDOJI}; static PyObject *__pyx_pw_5talib_7_ta_lib_437stream_CDLDRAGONFLYDOJI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -57864,7 +56973,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1263, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1263, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -57887,7 +56996,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLDRAGONFLYDOJI", 0) < 0) __PYX_ERR(5, 1263, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLDRAGONFLYDOJI", 0) < (0)) __PYX_ERR(5, 1263, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLDRAGONFLYDOJI", 1, 4, 4, i); __PYX_ERR(5, 1263, __pyx_L3_error) } } @@ -57995,7 +57104,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_436stream_CDLDRAGONFLYDOJI(CYTHON_UNUS __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1293, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1293, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -58038,7 +57147,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_438stream_CDLENGULFING, "stream_CDLENGULFING(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLENGULFING(open, high, low, close)\n\nEngulfing Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_438stream_CDLENGULFING, "stream_CDLENGULFING(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLENGULFING(open, high, low, close)\n\nEngulfing Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_439stream_CDLENGULFING = {"stream_CDLENGULFING", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_439stream_CDLENGULFING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_438stream_CDLENGULFING}; static PyObject *__pyx_pw_5talib_7_ta_lib_439stream_CDLENGULFING(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -58073,7 +57182,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1299, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1299, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -58096,7 +57205,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLENGULFING", 0) < 0) __PYX_ERR(5, 1299, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLENGULFING", 0) < (0)) __PYX_ERR(5, 1299, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLENGULFING", 1, 4, 4, i); __PYX_ERR(5, 1299, __pyx_L3_error) } } @@ -58204,7 +57313,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_438stream_CDLENGULFING(CYTHON_UNUSED P __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1329, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1329, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -58247,7 +57356,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_440stream_CDLEVENINGDOJISTAR, "stream_CDLEVENINGDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\nCDLEVENINGDOJISTAR(open, high, low, close[, penetration=?])\n\nEvening Doji Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.3\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_440stream_CDLEVENINGDOJISTAR, "stream_CDLEVENINGDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\n\nCDLEVENINGDOJISTAR(open, high, low, close[, penetration=?])\n\nEvening Doji Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.3\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_441stream_CDLEVENINGDOJISTAR = {"stream_CDLEVENINGDOJISTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_441stream_CDLEVENINGDOJISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_440stream_CDLEVENINGDOJISTAR}; static PyObject *__pyx_pw_5talib_7_ta_lib_441stream_CDLEVENINGDOJISTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -58283,7 +57392,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1335, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1335, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 5: @@ -58310,7 +57419,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLEVENINGDOJISTAR", 0) < 0) __PYX_ERR(5, 1335, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLEVENINGDOJISTAR", 0) < (0)) __PYX_ERR(5, 1335, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGDOJISTAR", 0, 4, 5, i); __PYX_ERR(5, 1335, __pyx_L3_error) } } @@ -58430,7 +57539,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_440stream_CDLEVENINGDOJISTAR(CYTHON_UN __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1367, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1367, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -58473,7 +57582,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_442stream_CDLEVENINGSTAR, "stream_CDLEVENINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\nCDLEVENINGSTAR(open, high, low, close[, penetration=?])\n\nEvening Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.3\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_442stream_CDLEVENINGSTAR, "stream_CDLEVENINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\n\nCDLEVENINGSTAR(open, high, low, close[, penetration=?])\n\nEvening Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.3\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_443stream_CDLEVENINGSTAR = {"stream_CDLEVENINGSTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_443stream_CDLEVENINGSTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_442stream_CDLEVENINGSTAR}; static PyObject *__pyx_pw_5talib_7_ta_lib_443stream_CDLEVENINGSTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -58509,7 +57618,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1373, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1373, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 5: @@ -58536,7 +57645,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLEVENINGSTAR", 0) < 0) __PYX_ERR(5, 1373, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLEVENINGSTAR", 0) < (0)) __PYX_ERR(5, 1373, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGSTAR", 0, 4, 5, i); __PYX_ERR(5, 1373, __pyx_L3_error) } } @@ -58656,7 +57765,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_442stream_CDLEVENINGSTAR(CYTHON_UNUSED __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1405, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1405, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -58699,7 +57808,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_444stream_CDLGAPSIDESIDEWHITE, "stream_CDLGAPSIDESIDEWHITE(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLGAPSIDESIDEWHITE(open, high, low, close)\n\nUp/Down-gap side-by-side white lines (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_444stream_CDLGAPSIDESIDEWHITE, "stream_CDLGAPSIDESIDEWHITE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLGAPSIDESIDEWHITE(open, high, low, close)\n\nUp/Down-gap side-by-side white lines (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_445stream_CDLGAPSIDESIDEWHITE = {"stream_CDLGAPSIDESIDEWHITE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_445stream_CDLGAPSIDESIDEWHITE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_444stream_CDLGAPSIDESIDEWHITE}; static PyObject *__pyx_pw_5talib_7_ta_lib_445stream_CDLGAPSIDESIDEWHITE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -58734,7 +57843,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1411, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1411, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -58757,7 +57866,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLGAPSIDESIDEWHITE", 0) < 0) __PYX_ERR(5, 1411, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLGAPSIDESIDEWHITE", 0) < (0)) __PYX_ERR(5, 1411, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLGAPSIDESIDEWHITE", 1, 4, 4, i); __PYX_ERR(5, 1411, __pyx_L3_error) } } @@ -58865,7 +57974,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_444stream_CDLGAPSIDESIDEWHITE(CYTHON_U __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1441, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1441, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -58908,7 +58017,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_446stream_CDLGRAVESTONEDOJI, "stream_CDLGRAVESTONEDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLGRAVESTONEDOJI(open, high, low, close)\n\nGravestone Doji (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_446stream_CDLGRAVESTONEDOJI, "stream_CDLGRAVESTONEDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLGRAVESTONEDOJI(open, high, low, close)\n\nGravestone Doji (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_447stream_CDLGRAVESTONEDOJI = {"stream_CDLGRAVESTONEDOJI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_447stream_CDLGRAVESTONEDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_446stream_CDLGRAVESTONEDOJI}; static PyObject *__pyx_pw_5talib_7_ta_lib_447stream_CDLGRAVESTONEDOJI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -58943,7 +58052,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1447, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1447, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -58966,7 +58075,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLGRAVESTONEDOJI", 0) < 0) __PYX_ERR(5, 1447, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLGRAVESTONEDOJI", 0) < (0)) __PYX_ERR(5, 1447, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLGRAVESTONEDOJI", 1, 4, 4, i); __PYX_ERR(5, 1447, __pyx_L3_error) } } @@ -59074,7 +58183,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_446stream_CDLGRAVESTONEDOJI(CYTHON_UNU __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1477, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1477, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -59117,7 +58226,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_448stream_CDLHAMMER, "stream_CDLHAMMER(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLHAMMER(open, high, low, close)\n\nHammer (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_448stream_CDLHAMMER, "stream_CDLHAMMER(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHAMMER(open, high, low, close)\n\nHammer (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_449stream_CDLHAMMER = {"stream_CDLHAMMER", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_449stream_CDLHAMMER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_448stream_CDLHAMMER}; static PyObject *__pyx_pw_5talib_7_ta_lib_449stream_CDLHAMMER(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -59152,7 +58261,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1483, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1483, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -59175,7 +58284,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHAMMER", 0) < 0) __PYX_ERR(5, 1483, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHAMMER", 0) < (0)) __PYX_ERR(5, 1483, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLHAMMER", 1, 4, 4, i); __PYX_ERR(5, 1483, __pyx_L3_error) } } @@ -59283,7 +58392,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_448stream_CDLHAMMER(CYTHON_UNUSED PyOb __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1513, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1513, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -59326,7 +58435,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_450stream_CDLHANGINGMAN, "stream_CDLHANGINGMAN(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLHANGINGMAN(open, high, low, close)\n\nHanging Man (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_450stream_CDLHANGINGMAN, "stream_CDLHANGINGMAN(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHANGINGMAN(open, high, low, close)\n\nHanging Man (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_451stream_CDLHANGINGMAN = {"stream_CDLHANGINGMAN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_451stream_CDLHANGINGMAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_450stream_CDLHANGINGMAN}; static PyObject *__pyx_pw_5talib_7_ta_lib_451stream_CDLHANGINGMAN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -59361,7 +58470,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1519, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1519, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -59384,7 +58493,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHANGINGMAN", 0) < 0) __PYX_ERR(5, 1519, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHANGINGMAN", 0) < (0)) __PYX_ERR(5, 1519, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLHANGINGMAN", 1, 4, 4, i); __PYX_ERR(5, 1519, __pyx_L3_error) } } @@ -59492,7 +58601,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_450stream_CDLHANGINGMAN(CYTHON_UNUSED __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1549, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1549, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -59535,7 +58644,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_452stream_CDLHARAMI, "stream_CDLHARAMI(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLHARAMI(open, high, low, close)\n\nHarami Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_452stream_CDLHARAMI, "stream_CDLHARAMI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHARAMI(open, high, low, close)\n\nHarami Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_453stream_CDLHARAMI = {"stream_CDLHARAMI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_453stream_CDLHARAMI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_452stream_CDLHARAMI}; static PyObject *__pyx_pw_5talib_7_ta_lib_453stream_CDLHARAMI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -59570,7 +58679,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1555, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1555, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -59593,7 +58702,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHARAMI", 0) < 0) __PYX_ERR(5, 1555, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHARAMI", 0) < (0)) __PYX_ERR(5, 1555, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMI", 1, 4, 4, i); __PYX_ERR(5, 1555, __pyx_L3_error) } } @@ -59701,7 +58810,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_452stream_CDLHARAMI(CYTHON_UNUSED PyOb __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1585, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1585, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -59744,7 +58853,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_454stream_CDLHARAMICROSS, "stream_CDLHARAMICROSS(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLHARAMICROSS(open, high, low, close)\n\nHarami Cross Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_454stream_CDLHARAMICROSS, "stream_CDLHARAMICROSS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHARAMICROSS(open, high, low, close)\n\nHarami Cross Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_455stream_CDLHARAMICROSS = {"stream_CDLHARAMICROSS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_455stream_CDLHARAMICROSS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_454stream_CDLHARAMICROSS}; static PyObject *__pyx_pw_5talib_7_ta_lib_455stream_CDLHARAMICROSS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -59779,7 +58888,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1591, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1591, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -59802,7 +58911,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHARAMICROSS", 0) < 0) __PYX_ERR(5, 1591, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHARAMICROSS", 0) < (0)) __PYX_ERR(5, 1591, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMICROSS", 1, 4, 4, i); __PYX_ERR(5, 1591, __pyx_L3_error) } } @@ -59910,7 +59019,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_454stream_CDLHARAMICROSS(CYTHON_UNUSED __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1621, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1621, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -59953,7 +59062,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_456stream_CDLHIGHWAVE, "stream_CDLHIGHWAVE(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLHIGHWAVE(open, high, low, close)\n\nHigh-Wave Candle (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_456stream_CDLHIGHWAVE, "stream_CDLHIGHWAVE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHIGHWAVE(open, high, low, close)\n\nHigh-Wave Candle (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_457stream_CDLHIGHWAVE = {"stream_CDLHIGHWAVE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_457stream_CDLHIGHWAVE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_456stream_CDLHIGHWAVE}; static PyObject *__pyx_pw_5talib_7_ta_lib_457stream_CDLHIGHWAVE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -59988,7 +59097,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1627, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1627, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -60011,7 +59120,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHIGHWAVE", 0) < 0) __PYX_ERR(5, 1627, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHIGHWAVE", 0) < (0)) __PYX_ERR(5, 1627, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLHIGHWAVE", 1, 4, 4, i); __PYX_ERR(5, 1627, __pyx_L3_error) } } @@ -60119,7 +59228,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_456stream_CDLHIGHWAVE(CYTHON_UNUSED Py __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1657, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1657, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -60162,7 +59271,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_458stream_CDLHIKKAKE, "stream_CDLHIKKAKE(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLHIKKAKE(open, high, low, close)\n\nHikkake Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_458stream_CDLHIKKAKE, "stream_CDLHIKKAKE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHIKKAKE(open, high, low, close)\n\nHikkake Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_459stream_CDLHIKKAKE = {"stream_CDLHIKKAKE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_459stream_CDLHIKKAKE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_458stream_CDLHIKKAKE}; static PyObject *__pyx_pw_5talib_7_ta_lib_459stream_CDLHIKKAKE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -60197,7 +59306,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1663, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1663, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -60220,7 +59329,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHIKKAKE", 0) < 0) __PYX_ERR(5, 1663, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHIKKAKE", 0) < (0)) __PYX_ERR(5, 1663, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKE", 1, 4, 4, i); __PYX_ERR(5, 1663, __pyx_L3_error) } } @@ -60328,7 +59437,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_458stream_CDLHIKKAKE(CYTHON_UNUSED PyO __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1693, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1693, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -60371,7 +59480,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_460stream_CDLHIKKAKEMOD, "stream_CDLHIKKAKEMOD(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLHIKKAKEMOD(open, high, low, close)\n\nModified Hikkake Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_460stream_CDLHIKKAKEMOD, "stream_CDLHIKKAKEMOD(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHIKKAKEMOD(open, high, low, close)\n\nModified Hikkake Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_461stream_CDLHIKKAKEMOD = {"stream_CDLHIKKAKEMOD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_461stream_CDLHIKKAKEMOD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_460stream_CDLHIKKAKEMOD}; static PyObject *__pyx_pw_5talib_7_ta_lib_461stream_CDLHIKKAKEMOD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -60406,7 +59515,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1699, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1699, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -60429,7 +59538,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHIKKAKEMOD", 0) < 0) __PYX_ERR(5, 1699, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHIKKAKEMOD", 0) < (0)) __PYX_ERR(5, 1699, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKEMOD", 1, 4, 4, i); __PYX_ERR(5, 1699, __pyx_L3_error) } } @@ -60537,7 +59646,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_460stream_CDLHIKKAKEMOD(CYTHON_UNUSED __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1729, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1729, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -60580,7 +59689,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_462stream_CDLHOMINGPIGEON, "stream_CDLHOMINGPIGEON(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLHOMINGPIGEON(open, high, low, close)\n\nHoming Pigeon (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_462stream_CDLHOMINGPIGEON, "stream_CDLHOMINGPIGEON(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHOMINGPIGEON(open, high, low, close)\n\nHoming Pigeon (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_463stream_CDLHOMINGPIGEON = {"stream_CDLHOMINGPIGEON", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_463stream_CDLHOMINGPIGEON, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_462stream_CDLHOMINGPIGEON}; static PyObject *__pyx_pw_5talib_7_ta_lib_463stream_CDLHOMINGPIGEON(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -60615,7 +59724,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1735, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1735, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -60638,7 +59747,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHOMINGPIGEON", 0) < 0) __PYX_ERR(5, 1735, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHOMINGPIGEON", 0) < (0)) __PYX_ERR(5, 1735, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLHOMINGPIGEON", 1, 4, 4, i); __PYX_ERR(5, 1735, __pyx_L3_error) } } @@ -60746,7 +59855,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_462stream_CDLHOMINGPIGEON(CYTHON_UNUSE __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1765, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1765, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -60789,7 +59898,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_464stream_CDLIDENTICAL3CROWS, "stream_CDLIDENTICAL3CROWS(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLIDENTICAL3CROWS(open, high, low, close)\n\nIdentical Three Crows (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_464stream_CDLIDENTICAL3CROWS, "stream_CDLIDENTICAL3CROWS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLIDENTICAL3CROWS(open, high, low, close)\n\nIdentical Three Crows (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_465stream_CDLIDENTICAL3CROWS = {"stream_CDLIDENTICAL3CROWS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_465stream_CDLIDENTICAL3CROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_464stream_CDLIDENTICAL3CROWS}; static PyObject *__pyx_pw_5talib_7_ta_lib_465stream_CDLIDENTICAL3CROWS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -60824,7 +59933,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1771, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1771, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -60847,7 +59956,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLIDENTICAL3CROWS", 0) < 0) __PYX_ERR(5, 1771, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLIDENTICAL3CROWS", 0) < (0)) __PYX_ERR(5, 1771, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLIDENTICAL3CROWS", 1, 4, 4, i); __PYX_ERR(5, 1771, __pyx_L3_error) } } @@ -60955,7 +60064,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_464stream_CDLIDENTICAL3CROWS(CYTHON_UN __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1801, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1801, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -60998,7 +60107,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_466stream_CDLINNECK, "stream_CDLINNECK(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLINNECK(open, high, low, close)\n\nIn-Neck Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_466stream_CDLINNECK, "stream_CDLINNECK(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLINNECK(open, high, low, close)\n\nIn-Neck Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_467stream_CDLINNECK = {"stream_CDLINNECK", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_467stream_CDLINNECK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_466stream_CDLINNECK}; static PyObject *__pyx_pw_5talib_7_ta_lib_467stream_CDLINNECK(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -61033,7 +60142,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1807, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1807, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -61056,7 +60165,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLINNECK", 0) < 0) __PYX_ERR(5, 1807, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLINNECK", 0) < (0)) __PYX_ERR(5, 1807, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLINNECK", 1, 4, 4, i); __PYX_ERR(5, 1807, __pyx_L3_error) } } @@ -61164,7 +60273,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_466stream_CDLINNECK(CYTHON_UNUSED PyOb __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1837, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1837, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -61207,7 +60316,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_468stream_CDLINVERTEDHAMMER, "stream_CDLINVERTEDHAMMER(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLINVERTEDHAMMER(open, high, low, close)\n\nInverted Hammer (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_468stream_CDLINVERTEDHAMMER, "stream_CDLINVERTEDHAMMER(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLINVERTEDHAMMER(open, high, low, close)\n\nInverted Hammer (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_469stream_CDLINVERTEDHAMMER = {"stream_CDLINVERTEDHAMMER", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_469stream_CDLINVERTEDHAMMER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_468stream_CDLINVERTEDHAMMER}; static PyObject *__pyx_pw_5talib_7_ta_lib_469stream_CDLINVERTEDHAMMER(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -61242,7 +60351,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1843, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1843, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -61265,7 +60374,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLINVERTEDHAMMER", 0) < 0) __PYX_ERR(5, 1843, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLINVERTEDHAMMER", 0) < (0)) __PYX_ERR(5, 1843, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLINVERTEDHAMMER", 1, 4, 4, i); __PYX_ERR(5, 1843, __pyx_L3_error) } } @@ -61373,7 +60482,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_468stream_CDLINVERTEDHAMMER(CYTHON_UNU __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1873, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1873, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -61416,7 +60525,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_470stream_CDLKICKING, "stream_CDLKICKING(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLKICKING(open, high, low, close)\n\nKicking (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_470stream_CDLKICKING, "stream_CDLKICKING(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLKICKING(open, high, low, close)\n\nKicking (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_471stream_CDLKICKING = {"stream_CDLKICKING", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_471stream_CDLKICKING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_470stream_CDLKICKING}; static PyObject *__pyx_pw_5talib_7_ta_lib_471stream_CDLKICKING(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -61451,7 +60560,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1879, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1879, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -61474,7 +60583,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLKICKING", 0) < 0) __PYX_ERR(5, 1879, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLKICKING", 0) < (0)) __PYX_ERR(5, 1879, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLKICKING", 1, 4, 4, i); __PYX_ERR(5, 1879, __pyx_L3_error) } } @@ -61582,7 +60691,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_470stream_CDLKICKING(CYTHON_UNUSED PyO __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1909, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1909, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -61625,7 +60734,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_472stream_CDLKICKINGBYLENGTH, "stream_CDLKICKINGBYLENGTH(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLKICKINGBYLENGTH(open, high, low, close)\n\nKicking - bull/bear determined by the longer marubozu (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_472stream_CDLKICKINGBYLENGTH, "stream_CDLKICKINGBYLENGTH(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLKICKINGBYLENGTH(open, high, low, close)\n\nKicking - bull/bear determined by the longer marubozu (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_473stream_CDLKICKINGBYLENGTH = {"stream_CDLKICKINGBYLENGTH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_473stream_CDLKICKINGBYLENGTH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_472stream_CDLKICKINGBYLENGTH}; static PyObject *__pyx_pw_5talib_7_ta_lib_473stream_CDLKICKINGBYLENGTH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -61660,7 +60769,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1915, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1915, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -61683,7 +60792,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLKICKINGBYLENGTH", 0) < 0) __PYX_ERR(5, 1915, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLKICKINGBYLENGTH", 0) < (0)) __PYX_ERR(5, 1915, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLKICKINGBYLENGTH", 1, 4, 4, i); __PYX_ERR(5, 1915, __pyx_L3_error) } } @@ -61791,7 +60900,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_472stream_CDLKICKINGBYLENGTH(CYTHON_UN __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1945, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1945, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -61834,7 +60943,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_474stream_CDLLADDERBOTTOM, "stream_CDLLADDERBOTTOM(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLLADDERBOTTOM(open, high, low, close)\n\nLadder Bottom (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_474stream_CDLLADDERBOTTOM, "stream_CDLLADDERBOTTOM(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLLADDERBOTTOM(open, high, low, close)\n\nLadder Bottom (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_475stream_CDLLADDERBOTTOM = {"stream_CDLLADDERBOTTOM", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_475stream_CDLLADDERBOTTOM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_474stream_CDLLADDERBOTTOM}; static PyObject *__pyx_pw_5talib_7_ta_lib_475stream_CDLLADDERBOTTOM(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -61869,7 +60978,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1951, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1951, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -61892,7 +61001,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLLADDERBOTTOM", 0) < 0) __PYX_ERR(5, 1951, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLLADDERBOTTOM", 0) < (0)) __PYX_ERR(5, 1951, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLLADDERBOTTOM", 1, 4, 4, i); __PYX_ERR(5, 1951, __pyx_L3_error) } } @@ -62000,7 +61109,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_474stream_CDLLADDERBOTTOM(CYTHON_UNUSE __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1981, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 1981, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -62043,7 +61152,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_476stream_CDLLONGLEGGEDDOJI, "stream_CDLLONGLEGGEDDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLLONGLEGGEDDOJI(open, high, low, close)\n\nLong Legged Doji (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_476stream_CDLLONGLEGGEDDOJI, "stream_CDLLONGLEGGEDDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLLONGLEGGEDDOJI(open, high, low, close)\n\nLong Legged Doji (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_477stream_CDLLONGLEGGEDDOJI = {"stream_CDLLONGLEGGEDDOJI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_477stream_CDLLONGLEGGEDDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_476stream_CDLLONGLEGGEDDOJI}; static PyObject *__pyx_pw_5talib_7_ta_lib_477stream_CDLLONGLEGGEDDOJI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -62078,7 +61187,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1987, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 1987, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -62101,7 +61210,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLLONGLEGGEDDOJI", 0) < 0) __PYX_ERR(5, 1987, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLLONGLEGGEDDOJI", 0) < (0)) __PYX_ERR(5, 1987, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLEGGEDDOJI", 1, 4, 4, i); __PYX_ERR(5, 1987, __pyx_L3_error) } } @@ -62209,7 +61318,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_476stream_CDLLONGLEGGEDDOJI(CYTHON_UNU __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2017, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2017, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -62252,7 +61361,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_478stream_CDLLONGLINE, "stream_CDLLONGLINE(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLLONGLINE(open, high, low, close)\n\nLong Line Candle (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_478stream_CDLLONGLINE, "stream_CDLLONGLINE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLLONGLINE(open, high, low, close)\n\nLong Line Candle (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_479stream_CDLLONGLINE = {"stream_CDLLONGLINE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_479stream_CDLLONGLINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_478stream_CDLLONGLINE}; static PyObject *__pyx_pw_5talib_7_ta_lib_479stream_CDLLONGLINE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -62287,7 +61396,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2023, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2023, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -62310,7 +61419,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLLONGLINE", 0) < 0) __PYX_ERR(5, 2023, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLLONGLINE", 0) < (0)) __PYX_ERR(5, 2023, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLINE", 1, 4, 4, i); __PYX_ERR(5, 2023, __pyx_L3_error) } } @@ -62418,7 +61527,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_478stream_CDLLONGLINE(CYTHON_UNUSED Py __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2053, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2053, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -62461,7 +61570,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_480stream_CDLMARUBOZU, "stream_CDLMARUBOZU(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLMARUBOZU(open, high, low, close)\n\nMarubozu (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_480stream_CDLMARUBOZU, "stream_CDLMARUBOZU(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLMARUBOZU(open, high, low, close)\n\nMarubozu (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_481stream_CDLMARUBOZU = {"stream_CDLMARUBOZU", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_481stream_CDLMARUBOZU, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_480stream_CDLMARUBOZU}; static PyObject *__pyx_pw_5talib_7_ta_lib_481stream_CDLMARUBOZU(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -62496,7 +61605,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2059, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2059, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -62519,7 +61628,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLMARUBOZU", 0) < 0) __PYX_ERR(5, 2059, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLMARUBOZU", 0) < (0)) __PYX_ERR(5, 2059, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLMARUBOZU", 1, 4, 4, i); __PYX_ERR(5, 2059, __pyx_L3_error) } } @@ -62627,7 +61736,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_480stream_CDLMARUBOZU(CYTHON_UNUSED Py __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2089, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2089, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -62670,7 +61779,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_482stream_CDLMATCHINGLOW, "stream_CDLMATCHINGLOW(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLMATCHINGLOW(open, high, low, close)\n\nMatching Low (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_482stream_CDLMATCHINGLOW, "stream_CDLMATCHINGLOW(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLMATCHINGLOW(open, high, low, close)\n\nMatching Low (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_483stream_CDLMATCHINGLOW = {"stream_CDLMATCHINGLOW", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_483stream_CDLMATCHINGLOW, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_482stream_CDLMATCHINGLOW}; static PyObject *__pyx_pw_5talib_7_ta_lib_483stream_CDLMATCHINGLOW(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -62705,7 +61814,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2095, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2095, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -62728,7 +61837,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLMATCHINGLOW", 0) < 0) __PYX_ERR(5, 2095, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLMATCHINGLOW", 0) < (0)) __PYX_ERR(5, 2095, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLMATCHINGLOW", 1, 4, 4, i); __PYX_ERR(5, 2095, __pyx_L3_error) } } @@ -62836,7 +61945,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_482stream_CDLMATCHINGLOW(CYTHON_UNUSED __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2125, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2125, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -62879,7 +61988,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_484stream_CDLMATHOLD, "stream_CDLMATHOLD(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.5)\nCDLMATHOLD(open, high, low, close[, penetration=?])\n\nMat Hold (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.5\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_484stream_CDLMATHOLD, "stream_CDLMATHOLD(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.5)\n\nCDLMATHOLD(open, high, low, close[, penetration=?])\n\nMat Hold (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.5\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_485stream_CDLMATHOLD = {"stream_CDLMATHOLD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_485stream_CDLMATHOLD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_484stream_CDLMATHOLD}; static PyObject *__pyx_pw_5talib_7_ta_lib_485stream_CDLMATHOLD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -62915,7 +62024,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2131, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2131, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 5: @@ -62942,7 +62051,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLMATHOLD", 0) < 0) __PYX_ERR(5, 2131, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLMATHOLD", 0) < (0)) __PYX_ERR(5, 2131, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLMATHOLD", 0, 4, 5, i); __PYX_ERR(5, 2131, __pyx_L3_error) } } @@ -63062,7 +62171,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_484stream_CDLMATHOLD(CYTHON_UNUSED PyO __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2163, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2163, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -63105,7 +62214,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_486stream_CDLMORNINGDOJISTAR, "stream_CDLMORNINGDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\nCDLMORNINGDOJISTAR(open, high, low, close[, penetration=?])\n\nMorning Doji Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.3\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_486stream_CDLMORNINGDOJISTAR, "stream_CDLMORNINGDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\n\nCDLMORNINGDOJISTAR(open, high, low, close[, penetration=?])\n\nMorning Doji Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.3\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_487stream_CDLMORNINGDOJISTAR = {"stream_CDLMORNINGDOJISTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_487stream_CDLMORNINGDOJISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_486stream_CDLMORNINGDOJISTAR}; static PyObject *__pyx_pw_5talib_7_ta_lib_487stream_CDLMORNINGDOJISTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -63141,7 +62250,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2169, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2169, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 5: @@ -63168,7 +62277,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLMORNINGDOJISTAR", 0) < 0) __PYX_ERR(5, 2169, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLMORNINGDOJISTAR", 0) < (0)) __PYX_ERR(5, 2169, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGDOJISTAR", 0, 4, 5, i); __PYX_ERR(5, 2169, __pyx_L3_error) } } @@ -63288,7 +62397,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_486stream_CDLMORNINGDOJISTAR(CYTHON_UN __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2201, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2201, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -63331,7 +62440,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_488stream_CDLMORNINGSTAR, "stream_CDLMORNINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\nCDLMORNINGSTAR(open, high, low, close[, penetration=?])\n\nMorning Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.3\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_488stream_CDLMORNINGSTAR, "stream_CDLMORNINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\n\nCDLMORNINGSTAR(open, high, low, close[, penetration=?])\n\nMorning Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nParameters:\n penetration: 0.3\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_489stream_CDLMORNINGSTAR = {"stream_CDLMORNINGSTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_489stream_CDLMORNINGSTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_488stream_CDLMORNINGSTAR}; static PyObject *__pyx_pw_5talib_7_ta_lib_489stream_CDLMORNINGSTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -63367,7 +62476,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2207, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2207, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 5: @@ -63394,7 +62503,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLMORNINGSTAR", 0) < 0) __PYX_ERR(5, 2207, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLMORNINGSTAR", 0) < (0)) __PYX_ERR(5, 2207, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGSTAR", 0, 4, 5, i); __PYX_ERR(5, 2207, __pyx_L3_error) } } @@ -63514,7 +62623,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_488stream_CDLMORNINGSTAR(CYTHON_UNUSED __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2239, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2239, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -63557,7 +62666,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_490stream_CDLONNECK, "stream_CDLONNECK(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLONNECK(open, high, low, close)\n\nOn-Neck Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_490stream_CDLONNECK, "stream_CDLONNECK(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLONNECK(open, high, low, close)\n\nOn-Neck Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_491stream_CDLONNECK = {"stream_CDLONNECK", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_491stream_CDLONNECK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_490stream_CDLONNECK}; static PyObject *__pyx_pw_5talib_7_ta_lib_491stream_CDLONNECK(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -63592,7 +62701,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2245, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2245, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -63615,7 +62724,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLONNECK", 0) < 0) __PYX_ERR(5, 2245, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLONNECK", 0) < (0)) __PYX_ERR(5, 2245, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLONNECK", 1, 4, 4, i); __PYX_ERR(5, 2245, __pyx_L3_error) } } @@ -63723,7 +62832,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_490stream_CDLONNECK(CYTHON_UNUSED PyOb __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2275, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2275, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -63766,7 +62875,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_492stream_CDLPIERCING, "stream_CDLPIERCING(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLPIERCING(open, high, low, close)\n\nPiercing Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_492stream_CDLPIERCING, "stream_CDLPIERCING(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLPIERCING(open, high, low, close)\n\nPiercing Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_493stream_CDLPIERCING = {"stream_CDLPIERCING", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_493stream_CDLPIERCING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_492stream_CDLPIERCING}; static PyObject *__pyx_pw_5talib_7_ta_lib_493stream_CDLPIERCING(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -63801,7 +62910,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2281, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2281, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -63824,7 +62933,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLPIERCING", 0) < 0) __PYX_ERR(5, 2281, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLPIERCING", 0) < (0)) __PYX_ERR(5, 2281, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLPIERCING", 1, 4, 4, i); __PYX_ERR(5, 2281, __pyx_L3_error) } } @@ -63932,7 +63041,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_492stream_CDLPIERCING(CYTHON_UNUSED Py __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2311, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2311, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -63975,7 +63084,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_494stream_CDLRICKSHAWMAN, "stream_CDLRICKSHAWMAN(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLRICKSHAWMAN(open, high, low, close)\n\nRickshaw Man (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_494stream_CDLRICKSHAWMAN, "stream_CDLRICKSHAWMAN(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLRICKSHAWMAN(open, high, low, close)\n\nRickshaw Man (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_495stream_CDLRICKSHAWMAN = {"stream_CDLRICKSHAWMAN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_495stream_CDLRICKSHAWMAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_494stream_CDLRICKSHAWMAN}; static PyObject *__pyx_pw_5talib_7_ta_lib_495stream_CDLRICKSHAWMAN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -64010,7 +63119,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2317, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2317, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -64033,7 +63142,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLRICKSHAWMAN", 0) < 0) __PYX_ERR(5, 2317, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLRICKSHAWMAN", 0) < (0)) __PYX_ERR(5, 2317, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLRICKSHAWMAN", 1, 4, 4, i); __PYX_ERR(5, 2317, __pyx_L3_error) } } @@ -64141,7 +63250,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_494stream_CDLRICKSHAWMAN(CYTHON_UNUSED __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2347, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2347, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -64184,7 +63293,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_496stream_CDLRISEFALL3METHODS, "stream_CDLRISEFALL3METHODS(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLRISEFALL3METHODS(open, high, low, close)\n\nRising/Falling Three Methods (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_496stream_CDLRISEFALL3METHODS, "stream_CDLRISEFALL3METHODS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLRISEFALL3METHODS(open, high, low, close)\n\nRising/Falling Three Methods (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_497stream_CDLRISEFALL3METHODS = {"stream_CDLRISEFALL3METHODS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_497stream_CDLRISEFALL3METHODS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_496stream_CDLRISEFALL3METHODS}; static PyObject *__pyx_pw_5talib_7_ta_lib_497stream_CDLRISEFALL3METHODS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -64219,7 +63328,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2353, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2353, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -64242,7 +63351,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLRISEFALL3METHODS", 0) < 0) __PYX_ERR(5, 2353, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLRISEFALL3METHODS", 0) < (0)) __PYX_ERR(5, 2353, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLRISEFALL3METHODS", 1, 4, 4, i); __PYX_ERR(5, 2353, __pyx_L3_error) } } @@ -64350,7 +63459,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_496stream_CDLRISEFALL3METHODS(CYTHON_U __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2383, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2383, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -64393,7 +63502,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_498stream_CDLSEPARATINGLINES, "stream_CDLSEPARATINGLINES(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLSEPARATINGLINES(open, high, low, close)\n\nSeparating Lines (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_498stream_CDLSEPARATINGLINES, "stream_CDLSEPARATINGLINES(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSEPARATINGLINES(open, high, low, close)\n\nSeparating Lines (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_499stream_CDLSEPARATINGLINES = {"stream_CDLSEPARATINGLINES", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_499stream_CDLSEPARATINGLINES, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_498stream_CDLSEPARATINGLINES}; static PyObject *__pyx_pw_5talib_7_ta_lib_499stream_CDLSEPARATINGLINES(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -64428,7 +63537,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2389, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2389, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -64451,7 +63560,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLSEPARATINGLINES", 0) < 0) __PYX_ERR(5, 2389, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLSEPARATINGLINES", 0) < (0)) __PYX_ERR(5, 2389, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLSEPARATINGLINES", 1, 4, 4, i); __PYX_ERR(5, 2389, __pyx_L3_error) } } @@ -64559,7 +63668,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_498stream_CDLSEPARATINGLINES(CYTHON_UN __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2419, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2419, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -64602,7 +63711,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_500stream_CDLSHOOTINGSTAR, "stream_CDLSHOOTINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLSHOOTINGSTAR(open, high, low, close)\n\nShooting Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_500stream_CDLSHOOTINGSTAR, "stream_CDLSHOOTINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSHOOTINGSTAR(open, high, low, close)\n\nShooting Star (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_501stream_CDLSHOOTINGSTAR = {"stream_CDLSHOOTINGSTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_501stream_CDLSHOOTINGSTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_500stream_CDLSHOOTINGSTAR}; static PyObject *__pyx_pw_5talib_7_ta_lib_501stream_CDLSHOOTINGSTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -64637,7 +63746,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2425, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2425, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -64660,7 +63769,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLSHOOTINGSTAR", 0) < 0) __PYX_ERR(5, 2425, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLSHOOTINGSTAR", 0) < (0)) __PYX_ERR(5, 2425, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLSHOOTINGSTAR", 1, 4, 4, i); __PYX_ERR(5, 2425, __pyx_L3_error) } } @@ -64768,7 +63877,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_500stream_CDLSHOOTINGSTAR(CYTHON_UNUSE __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2455, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2455, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -64811,7 +63920,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_502stream_CDLSHORTLINE, "stream_CDLSHORTLINE(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLSHORTLINE(open, high, low, close)\n\nShort Line Candle (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_502stream_CDLSHORTLINE, "stream_CDLSHORTLINE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSHORTLINE(open, high, low, close)\n\nShort Line Candle (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_503stream_CDLSHORTLINE = {"stream_CDLSHORTLINE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_503stream_CDLSHORTLINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_502stream_CDLSHORTLINE}; static PyObject *__pyx_pw_5talib_7_ta_lib_503stream_CDLSHORTLINE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -64846,7 +63955,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2461, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2461, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -64869,7 +63978,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLSHORTLINE", 0) < 0) __PYX_ERR(5, 2461, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLSHORTLINE", 0) < (0)) __PYX_ERR(5, 2461, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLSHORTLINE", 1, 4, 4, i); __PYX_ERR(5, 2461, __pyx_L3_error) } } @@ -64977,7 +64086,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_502stream_CDLSHORTLINE(CYTHON_UNUSED P __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2491, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2491, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -65020,7 +64129,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_504stream_CDLSPINNINGTOP, "stream_CDLSPINNINGTOP(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLSPINNINGTOP(open, high, low, close)\n\nSpinning Top (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_504stream_CDLSPINNINGTOP, "stream_CDLSPINNINGTOP(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSPINNINGTOP(open, high, low, close)\n\nSpinning Top (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_505stream_CDLSPINNINGTOP = {"stream_CDLSPINNINGTOP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_505stream_CDLSPINNINGTOP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_504stream_CDLSPINNINGTOP}; static PyObject *__pyx_pw_5talib_7_ta_lib_505stream_CDLSPINNINGTOP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -65055,7 +64164,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2497, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2497, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -65078,7 +64187,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLSPINNINGTOP", 0) < 0) __PYX_ERR(5, 2497, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLSPINNINGTOP", 0) < (0)) __PYX_ERR(5, 2497, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLSPINNINGTOP", 1, 4, 4, i); __PYX_ERR(5, 2497, __pyx_L3_error) } } @@ -65186,7 +64295,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_504stream_CDLSPINNINGTOP(CYTHON_UNUSED __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2527, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2527, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -65229,7 +64338,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_506stream_CDLSTALLEDPATTERN, "stream_CDLSTALLEDPATTERN(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLSTALLEDPATTERN(open, high, low, close)\n\nStalled Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_506stream_CDLSTALLEDPATTERN, "stream_CDLSTALLEDPATTERN(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSTALLEDPATTERN(open, high, low, close)\n\nStalled Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_507stream_CDLSTALLEDPATTERN = {"stream_CDLSTALLEDPATTERN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_507stream_CDLSTALLEDPATTERN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_506stream_CDLSTALLEDPATTERN}; static PyObject *__pyx_pw_5talib_7_ta_lib_507stream_CDLSTALLEDPATTERN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -65264,7 +64373,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2533, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2533, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -65287,7 +64396,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLSTALLEDPATTERN", 0) < 0) __PYX_ERR(5, 2533, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLSTALLEDPATTERN", 0) < (0)) __PYX_ERR(5, 2533, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLSTALLEDPATTERN", 1, 4, 4, i); __PYX_ERR(5, 2533, __pyx_L3_error) } } @@ -65395,7 +64504,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_506stream_CDLSTALLEDPATTERN(CYTHON_UNU __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2563, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2563, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -65438,7 +64547,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_508stream_CDLSTICKSANDWICH, "stream_CDLSTICKSANDWICH(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLSTICKSANDWICH(open, high, low, close)\n\nStick Sandwich (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_508stream_CDLSTICKSANDWICH, "stream_CDLSTICKSANDWICH(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSTICKSANDWICH(open, high, low, close)\n\nStick Sandwich (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_509stream_CDLSTICKSANDWICH = {"stream_CDLSTICKSANDWICH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_509stream_CDLSTICKSANDWICH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_508stream_CDLSTICKSANDWICH}; static PyObject *__pyx_pw_5talib_7_ta_lib_509stream_CDLSTICKSANDWICH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -65473,7 +64582,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2569, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2569, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -65496,7 +64605,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLSTICKSANDWICH", 0) < 0) __PYX_ERR(5, 2569, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLSTICKSANDWICH", 0) < (0)) __PYX_ERR(5, 2569, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLSTICKSANDWICH", 1, 4, 4, i); __PYX_ERR(5, 2569, __pyx_L3_error) } } @@ -65604,7 +64713,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_508stream_CDLSTICKSANDWICH(CYTHON_UNUS __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2599, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2599, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -65647,7 +64756,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_510stream_CDLTAKURI, "stream_CDLTAKURI(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLTAKURI(open, high, low, close)\n\nTakuri (Dragonfly Doji with very long lower shadow) (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_510stream_CDLTAKURI, "stream_CDLTAKURI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLTAKURI(open, high, low, close)\n\nTakuri (Dragonfly Doji with very long lower shadow) (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_511stream_CDLTAKURI = {"stream_CDLTAKURI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_511stream_CDLTAKURI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_510stream_CDLTAKURI}; static PyObject *__pyx_pw_5talib_7_ta_lib_511stream_CDLTAKURI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -65682,7 +64791,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2605, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2605, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -65705,7 +64814,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLTAKURI", 0) < 0) __PYX_ERR(5, 2605, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLTAKURI", 0) < (0)) __PYX_ERR(5, 2605, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLTAKURI", 1, 4, 4, i); __PYX_ERR(5, 2605, __pyx_L3_error) } } @@ -65813,7 +64922,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_510stream_CDLTAKURI(CYTHON_UNUSED PyOb __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2635, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2635, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -65856,7 +64965,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_512stream_CDLTASUKIGAP, "stream_CDLTASUKIGAP(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLTASUKIGAP(open, high, low, close)\n\nTasuki Gap (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_512stream_CDLTASUKIGAP, "stream_CDLTASUKIGAP(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLTASUKIGAP(open, high, low, close)\n\nTasuki Gap (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_513stream_CDLTASUKIGAP = {"stream_CDLTASUKIGAP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_513stream_CDLTASUKIGAP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_512stream_CDLTASUKIGAP}; static PyObject *__pyx_pw_5talib_7_ta_lib_513stream_CDLTASUKIGAP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -65891,7 +65000,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2641, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2641, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -65914,7 +65023,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLTASUKIGAP", 0) < 0) __PYX_ERR(5, 2641, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLTASUKIGAP", 0) < (0)) __PYX_ERR(5, 2641, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLTASUKIGAP", 1, 4, 4, i); __PYX_ERR(5, 2641, __pyx_L3_error) } } @@ -66022,7 +65131,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_512stream_CDLTASUKIGAP(CYTHON_UNUSED P __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2671, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2671, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -66065,7 +65174,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_514stream_CDLTHRUSTING, "stream_CDLTHRUSTING(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLTHRUSTING(open, high, low, close)\n\nThrusting Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_514stream_CDLTHRUSTING, "stream_CDLTHRUSTING(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLTHRUSTING(open, high, low, close)\n\nThrusting Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_515stream_CDLTHRUSTING = {"stream_CDLTHRUSTING", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_515stream_CDLTHRUSTING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_514stream_CDLTHRUSTING}; static PyObject *__pyx_pw_5talib_7_ta_lib_515stream_CDLTHRUSTING(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -66100,7 +65209,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2677, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2677, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -66123,7 +65232,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLTHRUSTING", 0) < 0) __PYX_ERR(5, 2677, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLTHRUSTING", 0) < (0)) __PYX_ERR(5, 2677, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLTHRUSTING", 1, 4, 4, i); __PYX_ERR(5, 2677, __pyx_L3_error) } } @@ -66231,7 +65340,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_514stream_CDLTHRUSTING(CYTHON_UNUSED P __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2707, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2707, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -66274,7 +65383,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_516stream_CDLTRISTAR, "stream_CDLTRISTAR(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLTRISTAR(open, high, low, close)\n\nTristar Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_516stream_CDLTRISTAR, "stream_CDLTRISTAR(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLTRISTAR(open, high, low, close)\n\nTristar Pattern (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_517stream_CDLTRISTAR = {"stream_CDLTRISTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_517stream_CDLTRISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_516stream_CDLTRISTAR}; static PyObject *__pyx_pw_5talib_7_ta_lib_517stream_CDLTRISTAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -66309,7 +65418,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2713, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2713, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -66332,7 +65441,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLTRISTAR", 0) < 0) __PYX_ERR(5, 2713, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLTRISTAR", 0) < (0)) __PYX_ERR(5, 2713, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLTRISTAR", 1, 4, 4, i); __PYX_ERR(5, 2713, __pyx_L3_error) } } @@ -66440,7 +65549,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_516stream_CDLTRISTAR(CYTHON_UNUSED PyO __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2743, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2743, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -66483,7 +65592,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_518stream_CDLUNIQUE3RIVER, "stream_CDLUNIQUE3RIVER(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLUNIQUE3RIVER(open, high, low, close)\n\nUnique 3 River (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_518stream_CDLUNIQUE3RIVER, "stream_CDLUNIQUE3RIVER(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLUNIQUE3RIVER(open, high, low, close)\n\nUnique 3 River (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_519stream_CDLUNIQUE3RIVER = {"stream_CDLUNIQUE3RIVER", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_519stream_CDLUNIQUE3RIVER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_518stream_CDLUNIQUE3RIVER}; static PyObject *__pyx_pw_5talib_7_ta_lib_519stream_CDLUNIQUE3RIVER(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -66518,7 +65627,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2749, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2749, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -66541,7 +65650,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLUNIQUE3RIVER", 0) < 0) __PYX_ERR(5, 2749, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLUNIQUE3RIVER", 0) < (0)) __PYX_ERR(5, 2749, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLUNIQUE3RIVER", 1, 4, 4, i); __PYX_ERR(5, 2749, __pyx_L3_error) } } @@ -66649,7 +65758,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_518stream_CDLUNIQUE3RIVER(CYTHON_UNUSE __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2779, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2779, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -66692,7 +65801,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_520stream_CDLUPSIDEGAP2CROWS, "stream_CDLUPSIDEGAP2CROWS(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLUPSIDEGAP2CROWS(open, high, low, close)\n\nUpside Gap Two Crows (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_520stream_CDLUPSIDEGAP2CROWS, "stream_CDLUPSIDEGAP2CROWS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLUPSIDEGAP2CROWS(open, high, low, close)\n\nUpside Gap Two Crows (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_521stream_CDLUPSIDEGAP2CROWS = {"stream_CDLUPSIDEGAP2CROWS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_521stream_CDLUPSIDEGAP2CROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_520stream_CDLUPSIDEGAP2CROWS}; static PyObject *__pyx_pw_5talib_7_ta_lib_521stream_CDLUPSIDEGAP2CROWS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -66727,7 +65836,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2785, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2785, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -66750,7 +65859,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLUPSIDEGAP2CROWS", 0) < 0) __PYX_ERR(5, 2785, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLUPSIDEGAP2CROWS", 0) < (0)) __PYX_ERR(5, 2785, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLUPSIDEGAP2CROWS", 1, 4, 4, i); __PYX_ERR(5, 2785, __pyx_L3_error) } } @@ -66858,7 +65967,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_520stream_CDLUPSIDEGAP2CROWS(CYTHON_UN __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2815, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2815, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -66901,7 +66010,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_522stream_CDLXSIDEGAP3METHODS, "stream_CDLXSIDEGAP3METHODS(ndarray open, ndarray high, ndarray low, ndarray close)\nCDLXSIDEGAP3METHODS(open, high, low, close)\n\nUpside/Downside Gap Three Methods (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_522stream_CDLXSIDEGAP3METHODS, "stream_CDLXSIDEGAP3METHODS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLXSIDEGAP3METHODS(open, high, low, close)\n\nUpside/Downside Gap Three Methods (Pattern Recognition)\n\nInputs:\n prices: ['open', 'high', 'low', 'close']\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_523stream_CDLXSIDEGAP3METHODS = {"stream_CDLXSIDEGAP3METHODS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_523stream_CDLXSIDEGAP3METHODS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_522stream_CDLXSIDEGAP3METHODS}; static PyObject *__pyx_pw_5talib_7_ta_lib_523stream_CDLXSIDEGAP3METHODS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -66936,7 +66045,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2821, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2821, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -66959,7 +66068,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLXSIDEGAP3METHODS", 0) < 0) __PYX_ERR(5, 2821, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLXSIDEGAP3METHODS", 0) < (0)) __PYX_ERR(5, 2821, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLXSIDEGAP3METHODS", 1, 4, 4, i); __PYX_ERR(5, 2821, __pyx_L3_error) } } @@ -67067,7 +66176,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_522stream_CDLXSIDEGAP3METHODS(CYTHON_U __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2851, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2851, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; @@ -67110,7 +66219,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_524stream_CEIL, "stream_CEIL(ndarray real)\nCEIL(real)\n\nVector Ceil (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_524stream_CEIL, "stream_CEIL(ndarray real)\n\nCEIL(real)\n\nVector Ceil (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_525stream_CEIL = {"stream_CEIL", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_525stream_CEIL, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_524stream_CEIL}; static PyObject *__pyx_pw_5talib_7_ta_lib_525stream_CEIL(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -67142,7 +66251,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2857, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2857, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -67153,7 +66262,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CEIL", 0) < 0) __PYX_ERR(5, 2857, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CEIL", 0) < (0)) __PYX_ERR(5, 2857, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CEIL", 1, 1, 1, i); __PYX_ERR(5, 2857, __pyx_L3_error) } } @@ -67260,7 +66369,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_526stream_CMO, "stream_CMO(ndarray real, int timeperiod=-0x80000000)\nCMO(real[, timeperiod=?])\n\nChande Momentum Oscillator (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_526stream_CMO, "stream_CMO(ndarray real, int timeperiod=-0x80000000)\n\nCMO(real[, timeperiod=?])\n\nChande Momentum Oscillator (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_527stream_CMO = {"stream_CMO", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_527stream_CMO, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_526stream_CMO}; static PyObject *__pyx_pw_5talib_7_ta_lib_527stream_CMO(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -67293,7 +66402,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2884, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2884, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -67308,7 +66417,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CMO", 0) < 0) __PYX_ERR(5, 2884, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CMO", 0) < (0)) __PYX_ERR(5, 2884, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CMO", 0, 1, 2, i); __PYX_ERR(5, 2884, __pyx_L3_error) } } @@ -67427,7 +66536,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_528stream_CORREL, "stream_CORREL(ndarray real0, ndarray real1, int timeperiod=-0x80000000)\nCORREL(real0, real1[, timeperiod=?])\n\nPearson's Correlation Coefficient (r) (Statistic Functions)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_528stream_CORREL, "stream_CORREL(ndarray real0, ndarray real1, int timeperiod=-0x80000000)\n\nCORREL(real0, real1[, timeperiod=?])\n\nPearson's Correlation Coefficient (r) (Statistic Functions)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_529stream_CORREL = {"stream_CORREL", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_529stream_CORREL, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_528stream_CORREL}; static PyObject *__pyx_pw_5talib_7_ta_lib_529stream_CORREL(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -67461,7 +66570,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2913, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2913, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -67480,7 +66589,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CORREL", 0) < 0) __PYX_ERR(5, 2913, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CORREL", 0) < (0)) __PYX_ERR(5, 2913, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CORREL", 0, 2, 3, i); __PYX_ERR(5, 2913, __pyx_L3_error) } } @@ -67574,7 +66683,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_528stream_CORREL(CYTHON_UNUSED PyObjec __pyx_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2940, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2940, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -67615,7 +66724,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_530stream_COS, "stream_COS(ndarray real)\nCOS(real)\n\nVector Trigonometric Cos (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_530stream_COS, "stream_COS(ndarray real)\n\nCOS(real)\n\nVector Trigonometric Cos (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_531stream_COS = {"stream_COS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_531stream_COS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_530stream_COS}; static PyObject *__pyx_pw_5talib_7_ta_lib_531stream_COS(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -67647,7 +66756,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2946, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2946, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -67658,7 +66767,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_COS", 0) < 0) __PYX_ERR(5, 2946, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_COS", 0) < (0)) __PYX_ERR(5, 2946, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_COS", 1, 1, 1, i); __PYX_ERR(5, 2946, __pyx_L3_error) } } @@ -67765,7 +66874,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_532stream_COSH, "stream_COSH(ndarray real)\nCOSH(real)\n\nVector Trigonometric Cosh (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_532stream_COSH, "stream_COSH(ndarray real)\n\nCOSH(real)\n\nVector Trigonometric Cosh (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_533stream_COSH = {"stream_COSH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_533stream_COSH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_532stream_COSH}; static PyObject *__pyx_pw_5talib_7_ta_lib_533stream_COSH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -67797,7 +66906,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2973, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 2973, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -67808,7 +66917,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_COSH", 0) < 0) __PYX_ERR(5, 2973, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_COSH", 0) < (0)) __PYX_ERR(5, 2973, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_COSH", 1, 1, 1, i); __PYX_ERR(5, 2973, __pyx_L3_error) } } @@ -67915,7 +67024,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_534stream_DEMA, "stream_DEMA(ndarray real, int timeperiod=-0x80000000)\nDEMA(real[, timeperiod=?])\n\nDouble Exponential Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_534stream_DEMA, "stream_DEMA(ndarray real, int timeperiod=-0x80000000)\n\nDEMA(real[, timeperiod=?])\n\nDouble Exponential Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_535stream_DEMA = {"stream_DEMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_535stream_DEMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_534stream_DEMA}; static PyObject *__pyx_pw_5talib_7_ta_lib_535stream_DEMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -67948,7 +67057,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3000, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3000, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -67963,7 +67072,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_DEMA", 0) < 0) __PYX_ERR(5, 3000, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_DEMA", 0) < (0)) __PYX_ERR(5, 3000, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_DEMA", 0, 1, 2, i); __PYX_ERR(5, 3000, __pyx_L3_error) } } @@ -68082,7 +67191,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_536stream_DIV, "stream_DIV(ndarray real0, ndarray real1)\nDIV(real0, real1)\n\nVector Arithmetic Div (Math Operators)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_536stream_DIV, "stream_DIV(ndarray real0, ndarray real1)\n\nDIV(real0, real1)\n\nVector Arithmetic Div (Math Operators)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_537stream_DIV = {"stream_DIV", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_537stream_DIV, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_536stream_DIV}; static PyObject *__pyx_pw_5talib_7_ta_lib_537stream_DIV(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -68115,7 +67224,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3029, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3029, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -68130,7 +67239,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_DIV", 0) < 0) __PYX_ERR(5, 3029, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_DIV", 0) < (0)) __PYX_ERR(5, 3029, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_DIV", 1, 2, 2, i); __PYX_ERR(5, 3029, __pyx_L3_error) } } @@ -68212,7 +67321,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_536stream_DIV(CYTHON_UNUSED PyObject * __pyx_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 3054, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 3054, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -68253,7 +67362,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_538stream_DX, "stream_DX(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\nDX(high, low, close[, timeperiod=?])\n\nDirectional Movement Index (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_538stream_DX, "stream_DX(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nDX(high, low, close[, timeperiod=?])\n\nDirectional Movement Index (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_539stream_DX = {"stream_DX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_539stream_DX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_538stream_DX}; static PyObject *__pyx_pw_5talib_7_ta_lib_539stream_DX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -68288,7 +67397,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3060, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3060, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -68311,7 +67420,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_DX", 0) < 0) __PYX_ERR(5, 3060, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_DX", 0) < (0)) __PYX_ERR(5, 3060, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_DX", 0, 3, 4, i); __PYX_ERR(5, 3060, __pyx_L3_error) } } @@ -68418,7 +67527,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_538stream_DX(CYTHON_UNUSED PyObject *_ __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 3089, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 3089, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -68460,7 +67569,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_540stream_EMA, "stream_EMA(ndarray real, int timeperiod=-0x80000000)\nEMA(real[, timeperiod=?])\n\nExponential Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_540stream_EMA, "stream_EMA(ndarray real, int timeperiod=-0x80000000)\n\nEMA(real[, timeperiod=?])\n\nExponential Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_541stream_EMA = {"stream_EMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_541stream_EMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_540stream_EMA}; static PyObject *__pyx_pw_5talib_7_ta_lib_541stream_EMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -68493,7 +67602,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3095, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3095, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -68508,7 +67617,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_EMA", 0) < 0) __PYX_ERR(5, 3095, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_EMA", 0) < (0)) __PYX_ERR(5, 3095, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_EMA", 0, 1, 2, i); __PYX_ERR(5, 3095, __pyx_L3_error) } } @@ -68627,7 +67736,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_542stream_EXP, "stream_EXP(ndarray real)\nEXP(real)\n\nVector Arithmetic Exp (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_542stream_EXP, "stream_EXP(ndarray real)\n\nEXP(real)\n\nVector Arithmetic Exp (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_543stream_EXP = {"stream_EXP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_543stream_EXP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_542stream_EXP}; static PyObject *__pyx_pw_5talib_7_ta_lib_543stream_EXP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -68659,7 +67768,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3124, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3124, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -68670,7 +67779,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_EXP", 0) < 0) __PYX_ERR(5, 3124, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_EXP", 0) < (0)) __PYX_ERR(5, 3124, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_EXP", 1, 1, 1, i); __PYX_ERR(5, 3124, __pyx_L3_error) } } @@ -68777,7 +67886,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_544stream_FLOOR, "stream_FLOOR(ndarray real)\nFLOOR(real)\n\nVector Floor (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_544stream_FLOOR, "stream_FLOOR(ndarray real)\n\nFLOOR(real)\n\nVector Floor (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_545stream_FLOOR = {"stream_FLOOR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_545stream_FLOOR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_544stream_FLOOR}; static PyObject *__pyx_pw_5talib_7_ta_lib_545stream_FLOOR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -68809,7 +67918,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3151, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3151, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -68820,7 +67929,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_FLOOR", 0) < 0) __PYX_ERR(5, 3151, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_FLOOR", 0) < (0)) __PYX_ERR(5, 3151, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_FLOOR", 1, 1, 1, i); __PYX_ERR(5, 3151, __pyx_L3_error) } } @@ -68927,7 +68036,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_546stream_HT_DCPERIOD, "stream_HT_DCPERIOD(ndarray real)\nHT_DCPERIOD(real)\n\nHilbert Transform - Dominant Cycle Period (Cycle Indicators)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_546stream_HT_DCPERIOD, "stream_HT_DCPERIOD(ndarray real)\n\nHT_DCPERIOD(real)\n\nHilbert Transform - Dominant Cycle Period (Cycle Indicators)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_547stream_HT_DCPERIOD = {"stream_HT_DCPERIOD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_547stream_HT_DCPERIOD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_546stream_HT_DCPERIOD}; static PyObject *__pyx_pw_5talib_7_ta_lib_547stream_HT_DCPERIOD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -68959,7 +68068,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3178, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3178, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -68970,7 +68079,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_HT_DCPERIOD", 0) < 0) __PYX_ERR(5, 3178, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_HT_DCPERIOD", 0) < (0)) __PYX_ERR(5, 3178, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_HT_DCPERIOD", 1, 1, 1, i); __PYX_ERR(5, 3178, __pyx_L3_error) } } @@ -69077,7 +68186,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_548stream_HT_DCPHASE, "stream_HT_DCPHASE(ndarray real)\nHT_DCPHASE(real)\n\nHilbert Transform - Dominant Cycle Phase (Cycle Indicators)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_548stream_HT_DCPHASE, "stream_HT_DCPHASE(ndarray real)\n\nHT_DCPHASE(real)\n\nHilbert Transform - Dominant Cycle Phase (Cycle Indicators)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_549stream_HT_DCPHASE = {"stream_HT_DCPHASE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_549stream_HT_DCPHASE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_548stream_HT_DCPHASE}; static PyObject *__pyx_pw_5talib_7_ta_lib_549stream_HT_DCPHASE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -69109,7 +68218,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3205, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3205, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -69120,7 +68229,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_HT_DCPHASE", 0) < 0) __PYX_ERR(5, 3205, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_HT_DCPHASE", 0) < (0)) __PYX_ERR(5, 3205, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_HT_DCPHASE", 1, 1, 1, i); __PYX_ERR(5, 3205, __pyx_L3_error) } } @@ -69227,7 +68336,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_550stream_HT_PHASOR, "stream_HT_PHASOR(ndarray real)\nHT_PHASOR(real)\n\nHilbert Transform - Phasor Components (Cycle Indicators)\n\nInputs:\n real: (any ndarray)\nOutputs:\n inphase\n quadrature"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_550stream_HT_PHASOR, "stream_HT_PHASOR(ndarray real)\n\nHT_PHASOR(real)\n\nHilbert Transform - Phasor Components (Cycle Indicators)\n\nInputs:\n real: (any ndarray)\nOutputs:\n inphase\n quadrature"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_551stream_HT_PHASOR = {"stream_HT_PHASOR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_551stream_HT_PHASOR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_550stream_HT_PHASOR}; static PyObject *__pyx_pw_5talib_7_ta_lib_551stream_HT_PHASOR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -69259,7 +68368,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3232, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3232, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -69270,7 +68379,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_HT_PHASOR", 0) < 0) __PYX_ERR(5, 3232, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_HT_PHASOR", 0) < (0)) __PYX_ERR(5, 3232, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_HT_PHASOR", 1, 1, 1, i); __PYX_ERR(5, 3232, __pyx_L3_error) } } @@ -69394,7 +68503,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_552stream_HT_SINE, "stream_HT_SINE(ndarray real)\nHT_SINE(real)\n\nHilbert Transform - SineWave (Cycle Indicators)\n\nInputs:\n real: (any ndarray)\nOutputs:\n sine\n leadsine"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_552stream_HT_SINE, "stream_HT_SINE(ndarray real)\n\nHT_SINE(real)\n\nHilbert Transform - SineWave (Cycle Indicators)\n\nInputs:\n real: (any ndarray)\nOutputs:\n sine\n leadsine"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_553stream_HT_SINE = {"stream_HT_SINE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_553stream_HT_SINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_552stream_HT_SINE}; static PyObject *__pyx_pw_5talib_7_ta_lib_553stream_HT_SINE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -69426,7 +68535,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3262, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3262, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -69437,7 +68546,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_HT_SINE", 0) < 0) __PYX_ERR(5, 3262, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_HT_SINE", 0) < (0)) __PYX_ERR(5, 3262, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_HT_SINE", 1, 1, 1, i); __PYX_ERR(5, 3262, __pyx_L3_error) } } @@ -69561,7 +68670,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_554stream_HT_TRENDLINE, "stream_HT_TRENDLINE(ndarray real)\nHT_TRENDLINE(real)\n\nHilbert Transform - Instantaneous Trendline (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_554stream_HT_TRENDLINE, "stream_HT_TRENDLINE(ndarray real)\n\nHT_TRENDLINE(real)\n\nHilbert Transform - Instantaneous Trendline (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_555stream_HT_TRENDLINE = {"stream_HT_TRENDLINE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_555stream_HT_TRENDLINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_554stream_HT_TRENDLINE}; static PyObject *__pyx_pw_5talib_7_ta_lib_555stream_HT_TRENDLINE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -69593,7 +68702,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3292, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3292, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -69604,7 +68713,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_HT_TRENDLINE", 0) < 0) __PYX_ERR(5, 3292, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_HT_TRENDLINE", 0) < (0)) __PYX_ERR(5, 3292, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_HT_TRENDLINE", 1, 1, 1, i); __PYX_ERR(5, 3292, __pyx_L3_error) } } @@ -69711,7 +68820,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_556stream_HT_TRENDMODE, "stream_HT_TRENDMODE(ndarray real)\nHT_TRENDMODE(real)\n\nHilbert Transform - Trend vs Cycle Mode (Cycle Indicators)\n\nInputs:\n real: (any ndarray)\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_556stream_HT_TRENDMODE, "stream_HT_TRENDMODE(ndarray real)\n\nHT_TRENDMODE(real)\n\nHilbert Transform - Trend vs Cycle Mode (Cycle Indicators)\n\nInputs:\n real: (any ndarray)\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_557stream_HT_TRENDMODE = {"stream_HT_TRENDMODE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_557stream_HT_TRENDMODE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_556stream_HT_TRENDMODE}; static PyObject *__pyx_pw_5talib_7_ta_lib_557stream_HT_TRENDMODE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -69743,7 +68852,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3319, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3319, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -69754,7 +68863,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_HT_TRENDMODE", 0) < 0) __PYX_ERR(5, 3319, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_HT_TRENDMODE", 0) < (0)) __PYX_ERR(5, 3319, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_HT_TRENDMODE", 1, 1, 1, i); __PYX_ERR(5, 3319, __pyx_L3_error) } } @@ -69861,7 +68970,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_558stream_IMI, "stream_IMI(ndarray open, ndarray close, int timeperiod=-0x80000000)\nIMI(open, close[, timeperiod=?])\n\nIntraday Momentum Index (Momentum Indicators)\n\nInputs:\n prices: ['open', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_558stream_IMI, "stream_IMI(ndarray open, ndarray close, int timeperiod=-0x80000000)\n\nIMI(open, close[, timeperiod=?])\n\nIntraday Momentum Index (Momentum Indicators)\n\nInputs:\n prices: ['open', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_559stream_IMI = {"stream_IMI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_559stream_IMI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_558stream_IMI}; static PyObject *__pyx_pw_5talib_7_ta_lib_559stream_IMI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -69895,7 +69004,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3346, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3346, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -69914,7 +69023,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_IMI", 0) < 0) __PYX_ERR(5, 3346, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_IMI", 0) < (0)) __PYX_ERR(5, 3346, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_IMI", 0, 2, 3, i); __PYX_ERR(5, 3346, __pyx_L3_error) } } @@ -70008,7 +69117,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_558stream_IMI(CYTHON_UNUSED PyObject * __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_open, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 3372, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_open, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 3372, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -70049,7 +69158,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_560stream_KAMA, "stream_KAMA(ndarray real, int timeperiod=-0x80000000)\nKAMA(real[, timeperiod=?])\n\nKaufman Adaptive Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_560stream_KAMA, "stream_KAMA(ndarray real, int timeperiod=-0x80000000)\n\nKAMA(real[, timeperiod=?])\n\nKaufman Adaptive Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_561stream_KAMA = {"stream_KAMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_561stream_KAMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_560stream_KAMA}; static PyObject *__pyx_pw_5talib_7_ta_lib_561stream_KAMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -70082,7 +69191,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3378, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3378, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -70097,7 +69206,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_KAMA", 0) < 0) __PYX_ERR(5, 3378, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_KAMA", 0) < (0)) __PYX_ERR(5, 3378, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_KAMA", 0, 1, 2, i); __PYX_ERR(5, 3378, __pyx_L3_error) } } @@ -70216,7 +69325,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_562stream_LINEARREG, "stream_LINEARREG(ndarray real, int timeperiod=-0x80000000)\nLINEARREG(real[, timeperiod=?])\n\nLinear Regression (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_562stream_LINEARREG, "stream_LINEARREG(ndarray real, int timeperiod=-0x80000000)\n\nLINEARREG(real[, timeperiod=?])\n\nLinear Regression (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_563stream_LINEARREG = {"stream_LINEARREG", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_563stream_LINEARREG, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_562stream_LINEARREG}; static PyObject *__pyx_pw_5talib_7_ta_lib_563stream_LINEARREG(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -70249,7 +69358,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3407, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3407, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -70264,7 +69373,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_LINEARREG", 0) < 0) __PYX_ERR(5, 3407, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_LINEARREG", 0) < (0)) __PYX_ERR(5, 3407, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_LINEARREG", 0, 1, 2, i); __PYX_ERR(5, 3407, __pyx_L3_error) } } @@ -70383,7 +69492,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_564stream_LINEARREG_ANGLE, "stream_LINEARREG_ANGLE(ndarray real, int timeperiod=-0x80000000)\nLINEARREG_ANGLE(real[, timeperiod=?])\n\nLinear Regression Angle (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_564stream_LINEARREG_ANGLE, "stream_LINEARREG_ANGLE(ndarray real, int timeperiod=-0x80000000)\n\nLINEARREG_ANGLE(real[, timeperiod=?])\n\nLinear Regression Angle (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_565stream_LINEARREG_ANGLE = {"stream_LINEARREG_ANGLE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_565stream_LINEARREG_ANGLE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_564stream_LINEARREG_ANGLE}; static PyObject *__pyx_pw_5talib_7_ta_lib_565stream_LINEARREG_ANGLE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -70416,7 +69525,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3436, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3436, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -70431,7 +69540,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_LINEARREG_ANGLE", 0) < 0) __PYX_ERR(5, 3436, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_LINEARREG_ANGLE", 0) < (0)) __PYX_ERR(5, 3436, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_LINEARREG_ANGLE", 0, 1, 2, i); __PYX_ERR(5, 3436, __pyx_L3_error) } } @@ -70550,7 +69659,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_566stream_LINEARREG_INTERCEPT, "stream_LINEARREG_INTERCEPT(ndarray real, int timeperiod=-0x80000000)\nLINEARREG_INTERCEPT(real[, timeperiod=?])\n\nLinear Regression Intercept (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_566stream_LINEARREG_INTERCEPT, "stream_LINEARREG_INTERCEPT(ndarray real, int timeperiod=-0x80000000)\n\nLINEARREG_INTERCEPT(real[, timeperiod=?])\n\nLinear Regression Intercept (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_567stream_LINEARREG_INTERCEPT = {"stream_LINEARREG_INTERCEPT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_567stream_LINEARREG_INTERCEPT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_566stream_LINEARREG_INTERCEPT}; static PyObject *__pyx_pw_5talib_7_ta_lib_567stream_LINEARREG_INTERCEPT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -70583,7 +69692,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3465, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3465, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -70598,7 +69707,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_LINEARREG_INTERCEPT", 0) < 0) __PYX_ERR(5, 3465, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_LINEARREG_INTERCEPT", 0) < (0)) __PYX_ERR(5, 3465, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_LINEARREG_INTERCEPT", 0, 1, 2, i); __PYX_ERR(5, 3465, __pyx_L3_error) } } @@ -70717,7 +69826,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_568stream_LINEARREG_SLOPE, "stream_LINEARREG_SLOPE(ndarray real, int timeperiod=-0x80000000)\nLINEARREG_SLOPE(real[, timeperiod=?])\n\nLinear Regression Slope (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_568stream_LINEARREG_SLOPE, "stream_LINEARREG_SLOPE(ndarray real, int timeperiod=-0x80000000)\n\nLINEARREG_SLOPE(real[, timeperiod=?])\n\nLinear Regression Slope (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_569stream_LINEARREG_SLOPE = {"stream_LINEARREG_SLOPE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_569stream_LINEARREG_SLOPE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_568stream_LINEARREG_SLOPE}; static PyObject *__pyx_pw_5talib_7_ta_lib_569stream_LINEARREG_SLOPE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -70750,7 +69859,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3494, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3494, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -70765,7 +69874,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_LINEARREG_SLOPE", 0) < 0) __PYX_ERR(5, 3494, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_LINEARREG_SLOPE", 0) < (0)) __PYX_ERR(5, 3494, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_LINEARREG_SLOPE", 0, 1, 2, i); __PYX_ERR(5, 3494, __pyx_L3_error) } } @@ -70884,7 +69993,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_570stream_LN, "stream_LN(ndarray real)\nLN(real)\n\nVector Log Natural (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_570stream_LN, "stream_LN(ndarray real)\n\nLN(real)\n\nVector Log Natural (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_571stream_LN = {"stream_LN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_571stream_LN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_570stream_LN}; static PyObject *__pyx_pw_5talib_7_ta_lib_571stream_LN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -70916,7 +70025,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3523, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3523, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -70927,7 +70036,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_LN", 0) < 0) __PYX_ERR(5, 3523, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_LN", 0) < (0)) __PYX_ERR(5, 3523, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_LN", 1, 1, 1, i); __PYX_ERR(5, 3523, __pyx_L3_error) } } @@ -71034,7 +70143,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_572stream_LOG10, "stream_LOG10(ndarray real)\nLOG10(real)\n\nVector Log10 (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_572stream_LOG10, "stream_LOG10(ndarray real)\n\nLOG10(real)\n\nVector Log10 (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_573stream_LOG10 = {"stream_LOG10", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_573stream_LOG10, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_572stream_LOG10}; static PyObject *__pyx_pw_5talib_7_ta_lib_573stream_LOG10(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -71066,7 +70175,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3550, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3550, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -71077,7 +70186,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_LOG10", 0) < 0) __PYX_ERR(5, 3550, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_LOG10", 0) < (0)) __PYX_ERR(5, 3550, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_LOG10", 1, 1, 1, i); __PYX_ERR(5, 3550, __pyx_L3_error) } } @@ -71184,7 +70293,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_574stream_MA, "stream_MA(ndarray real, int timeperiod=-0x80000000, int matype=0)\nMA(real[, timeperiod=?, matype=?])\n\nMoving average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\n matype: 0 (Simple Moving Average)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_574stream_MA, "stream_MA(ndarray real, int timeperiod=-0x80000000, int matype=0)\n\nMA(real[, timeperiod=?, matype=?])\n\nMoving average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\n matype: 0 (Simple Moving Average)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_575stream_MA = {"stream_MA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_575stream_MA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_574stream_MA}; static PyObject *__pyx_pw_5talib_7_ta_lib_575stream_MA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -71218,7 +70327,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_matype,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3577, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3577, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -71237,7 +70346,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MA", 0) < 0) __PYX_ERR(5, 3577, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MA", 0) < (0)) __PYX_ERR(5, 3577, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MA", 0, 1, 3, i); __PYX_ERR(5, 3577, __pyx_L3_error) } } @@ -71365,7 +70474,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_576stream_MACD, "stream_MACD(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int signalperiod=-0x80000000)\nMACD(real[, fastperiod=?, slowperiod=?, signalperiod=?])\n\nMoving Average Convergence/Divergence (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n fastperiod: 12\n slowperiod: 26\n signalperiod: 9\nOutputs:\n macd\n macdsignal\n macdhist"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_576stream_MACD, "stream_MACD(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int signalperiod=-0x80000000)\n\nMACD(real[, fastperiod=?, slowperiod=?, signalperiod=?])\n\nMoving Average Convergence/Divergence (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n fastperiod: 12\n slowperiod: 26\n signalperiod: 9\nOutputs:\n macd\n macdsignal\n macdhist"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_577stream_MACD = {"stream_MACD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_577stream_MACD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_576stream_MACD}; static PyObject *__pyx_pw_5talib_7_ta_lib_577stream_MACD(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -71400,7 +70509,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_fastperiod,&__pyx_mstate_global->__pyx_n_u_slowperiod,&__pyx_mstate_global->__pyx_n_u_signalperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3607, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3607, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -71423,7 +70532,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MACD", 0) < 0) __PYX_ERR(5, 3607, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MACD", 0) < (0)) __PYX_ERR(5, 3607, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MACD", 0, 1, 4, i); __PYX_ERR(5, 3607, __pyx_L3_error) } } @@ -71587,7 +70696,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_578stream_MACDEXT, "stream_MACDEXT(ndarray real, int fastperiod=-0x80000000, int fastmatype=0, int slowperiod=-0x80000000, int slowmatype=0, int signalperiod=-0x80000000, int signalmatype=0)\nMACDEXT(real[, fastperiod=?, fastmatype=?, slowperiod=?, slowmatype=?, signalperiod=?, signalmatype=?])\n\nMACD with controllable MA type (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n fastperiod: 12\n fastmatype: 0\n slowperiod: 26\n slowmatype: 0\n signalperiod: 9\n signalmatype: 0\nOutputs:\n macd\n macdsignal\n macdhist"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_578stream_MACDEXT, "stream_MACDEXT(ndarray real, int fastperiod=-0x80000000, int fastmatype=0, int slowperiod=-0x80000000, int slowmatype=0, int signalperiod=-0x80000000, int signalmatype=0)\n\nMACDEXT(real[, fastperiod=?, fastmatype=?, slowperiod=?, slowmatype=?, signalperiod=?, signalmatype=?])\n\nMACD with controllable MA type (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n fastperiod: 12\n fastmatype: 0\n slowperiod: 26\n slowmatype: 0\n signalperiod: 9\n signalmatype: 0\nOutputs:\n macd\n macdsignal\n macdhist"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_579stream_MACDEXT = {"stream_MACDEXT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_579stream_MACDEXT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_578stream_MACDEXT}; static PyObject *__pyx_pw_5talib_7_ta_lib_579stream_MACDEXT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -71625,7 +70734,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_fastperiod,&__pyx_mstate_global->__pyx_n_u_fastmatype,&__pyx_mstate_global->__pyx_n_u_slowperiod,&__pyx_mstate_global->__pyx_n_u_slowmatype,&__pyx_mstate_global->__pyx_n_u_signalperiod,&__pyx_mstate_global->__pyx_n_u_signalmatype,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3644, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3644, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 7: @@ -71660,7 +70769,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MACDEXT", 0) < 0) __PYX_ERR(5, 3644, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MACDEXT", 0) < (0)) __PYX_ERR(5, 3644, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MACDEXT", 0, 1, 7, i); __PYX_ERR(5, 3644, __pyx_L3_error) } } @@ -71851,7 +70960,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_580stream_MACDFIX, "stream_MACDFIX(ndarray real, int signalperiod=-0x80000000)\nMACDFIX(real[, signalperiod=?])\n\nMoving Average Convergence/Divergence Fix 12/26 (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n signalperiod: 9\nOutputs:\n macd\n macdsignal\n macdhist"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_580stream_MACDFIX, "stream_MACDFIX(ndarray real, int signalperiod=-0x80000000)\n\nMACDFIX(real[, signalperiod=?])\n\nMoving Average Convergence/Divergence Fix 12/26 (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n signalperiod: 9\nOutputs:\n macd\n macdsignal\n macdhist"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_581stream_MACDFIX = {"stream_MACDFIX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_581stream_MACDFIX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_580stream_MACDFIX}; static PyObject *__pyx_pw_5talib_7_ta_lib_581stream_MACDFIX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -71884,7 +70993,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_signalperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3684, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3684, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -71899,7 +71008,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MACDFIX", 0) < 0) __PYX_ERR(5, 3684, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MACDFIX", 0) < (0)) __PYX_ERR(5, 3684, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MACDFIX", 0, 1, 2, i); __PYX_ERR(5, 3684, __pyx_L3_error) } } @@ -72045,7 +71154,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_582stream_MAMA, "stream_MAMA(ndarray real, double fastlimit=-4e37, double slowlimit=-4e37)\nMAMA(real[, fastlimit=?, slowlimit=?])\n\nMESA Adaptive Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n fastlimit: 0.5\n slowlimit: 0.05\nOutputs:\n mama\n fama"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_582stream_MAMA, "stream_MAMA(ndarray real, double fastlimit=-4e37, double slowlimit=-4e37)\n\nMAMA(real[, fastlimit=?, slowlimit=?])\n\nMESA Adaptive Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n fastlimit: 0.5\n slowlimit: 0.05\nOutputs:\n mama\n fama"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_583stream_MAMA = {"stream_MAMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_583stream_MAMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_582stream_MAMA}; static PyObject *__pyx_pw_5talib_7_ta_lib_583stream_MAMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -72079,7 +71188,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_fastlimit,&__pyx_mstate_global->__pyx_n_u_slowlimit,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3719, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3719, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -72098,7 +71207,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MAMA", 0) < 0) __PYX_ERR(5, 3719, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MAMA", 0) < (0)) __PYX_ERR(5, 3719, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MAMA", 0, 1, 3, i); __PYX_ERR(5, 3719, __pyx_L3_error) } } @@ -72243,7 +71352,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_584stream_MAVP, "stream_MAVP(ndarray real, ndarray periods, int minperiod=-0x80000000, int maxperiod=-0x80000000, int matype=0)\nMAVP(real, periods[, minperiod=?, maxperiod=?, matype=?])\n\nMoving average with variable period (Overlap Studies)\n\nInputs:\n real: (any ndarray)\n periods: (any ndarray)\nParameters:\n minperiod: 2\n maxperiod: 30\n matype: 0 (Simple Moving Average)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_584stream_MAVP, "stream_MAVP(ndarray real, ndarray periods, int minperiod=-0x80000000, int maxperiod=-0x80000000, int matype=0)\n\nMAVP(real, periods[, minperiod=?, maxperiod=?, matype=?])\n\nMoving average with variable period (Overlap Studies)\n\nInputs:\n real: (any ndarray)\n periods: (any ndarray)\nParameters:\n minperiod: 2\n maxperiod: 30\n matype: 0 (Simple Moving Average)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_585stream_MAVP = {"stream_MAVP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_585stream_MAVP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_584stream_MAVP}; static PyObject *__pyx_pw_5talib_7_ta_lib_585stream_MAVP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -72279,7 +71388,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_periods,&__pyx_mstate_global->__pyx_n_u_minperiod,&__pyx_mstate_global->__pyx_n_u_maxperiod,&__pyx_mstate_global->__pyx_n_u_matype,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3752, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3752, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 5: @@ -72306,7 +71415,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MAVP", 0) < 0) __PYX_ERR(5, 3752, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MAVP", 0) < (0)) __PYX_ERR(5, 3752, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MAVP", 0, 2, 5, i); __PYX_ERR(5, 3752, __pyx_L3_error) } } @@ -72418,7 +71527,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_584stream_MAVP(CYTHON_UNUSED PyObject __pyx_v_periods_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_periods)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real, __pyx_v_periods); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 3781, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real, __pyx_v_periods); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 3781, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -72459,7 +71568,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_586stream_MAX, "stream_MAX(ndarray real, int timeperiod=-0x80000000)\nMAX(real[, timeperiod=?])\n\nHighest value over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_586stream_MAX, "stream_MAX(ndarray real, int timeperiod=-0x80000000)\n\nMAX(real[, timeperiod=?])\n\nHighest value over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_587stream_MAX = {"stream_MAX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_587stream_MAX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_586stream_MAX}; static PyObject *__pyx_pw_5talib_7_ta_lib_587stream_MAX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -72492,7 +71601,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3787, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3787, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -72507,7 +71616,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MAX", 0) < 0) __PYX_ERR(5, 3787, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MAX", 0) < (0)) __PYX_ERR(5, 3787, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MAX", 0, 1, 2, i); __PYX_ERR(5, 3787, __pyx_L3_error) } } @@ -72626,7 +71735,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_588stream_MAXINDEX, "stream_MAXINDEX(ndarray real, int timeperiod=-0x80000000)\nMAXINDEX(real[, timeperiod=?])\n\nIndex of highest value over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_588stream_MAXINDEX, "stream_MAXINDEX(ndarray real, int timeperiod=-0x80000000)\n\nMAXINDEX(real[, timeperiod=?])\n\nIndex of highest value over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_589stream_MAXINDEX = {"stream_MAXINDEX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_589stream_MAXINDEX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_588stream_MAXINDEX}; static PyObject *__pyx_pw_5talib_7_ta_lib_589stream_MAXINDEX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -72659,7 +71768,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3816, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3816, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -72674,7 +71783,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MAXINDEX", 0) < 0) __PYX_ERR(5, 3816, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MAXINDEX", 0) < (0)) __PYX_ERR(5, 3816, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MAXINDEX", 0, 1, 2, i); __PYX_ERR(5, 3816, __pyx_L3_error) } } @@ -72793,7 +71902,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_590stream_MEDPRICE, "stream_MEDPRICE(ndarray high, ndarray low)\nMEDPRICE(high, low)\n\nMedian Price (Price Transform)\n\nInputs:\n prices: ['high', 'low']\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_590stream_MEDPRICE, "stream_MEDPRICE(ndarray high, ndarray low)\n\nMEDPRICE(high, low)\n\nMedian Price (Price Transform)\n\nInputs:\n prices: ['high', 'low']\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_591stream_MEDPRICE = {"stream_MEDPRICE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_591stream_MEDPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_590stream_MEDPRICE}; static PyObject *__pyx_pw_5talib_7_ta_lib_591stream_MEDPRICE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -72826,7 +71935,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3845, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3845, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -72841,7 +71950,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MEDPRICE", 0) < 0) __PYX_ERR(5, 3845, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MEDPRICE", 0) < (0)) __PYX_ERR(5, 3845, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MEDPRICE", 1, 2, 2, i); __PYX_ERR(5, 3845, __pyx_L3_error) } } @@ -72923,7 +72032,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_590stream_MEDPRICE(CYTHON_UNUSED PyObj __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 3869, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 3869, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -72964,7 +72073,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_592stream_MFI, "stream_MFI(ndarray high, ndarray low, ndarray close, ndarray volume, int timeperiod=-0x80000000)\nMFI(high, low, close, volume[, timeperiod=?])\n\nMoney Flow Index (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close', 'volume']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_592stream_MFI, "stream_MFI(ndarray high, ndarray low, ndarray close, ndarray volume, int timeperiod=-0x80000000)\n\nMFI(high, low, close, volume[, timeperiod=?])\n\nMoney Flow Index (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close', 'volume']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_593stream_MFI = {"stream_MFI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_593stream_MFI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_592stream_MFI}; static PyObject *__pyx_pw_5talib_7_ta_lib_593stream_MFI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -73000,7 +72109,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_volume,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3875, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3875, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 5: @@ -73027,7 +72136,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MFI", 0) < 0) __PYX_ERR(5, 3875, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MFI", 0) < (0)) __PYX_ERR(5, 3875, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MFI", 0, 4, 5, i); __PYX_ERR(5, 3875, __pyx_L3_error) } } @@ -73147,7 +72256,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_592stream_MFI(CYTHON_UNUSED PyObject * __pyx_v_volume_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 3907, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 3907, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -73190,7 +72299,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_594stream_MIDPOINT, "stream_MIDPOINT(ndarray real, int timeperiod=-0x80000000)\nMIDPOINT(real[, timeperiod=?])\n\nMidPoint over period (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_594stream_MIDPOINT, "stream_MIDPOINT(ndarray real, int timeperiod=-0x80000000)\n\nMIDPOINT(real[, timeperiod=?])\n\nMidPoint over period (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_595stream_MIDPOINT = {"stream_MIDPOINT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_595stream_MIDPOINT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_594stream_MIDPOINT}; static PyObject *__pyx_pw_5talib_7_ta_lib_595stream_MIDPOINT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -73223,7 +72332,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3913, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3913, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -73238,7 +72347,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MIDPOINT", 0) < 0) __PYX_ERR(5, 3913, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MIDPOINT", 0) < (0)) __PYX_ERR(5, 3913, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MIDPOINT", 0, 1, 2, i); __PYX_ERR(5, 3913, __pyx_L3_error) } } @@ -73357,7 +72466,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_596stream_MIDPRICE, "stream_MIDPRICE(ndarray high, ndarray low, int timeperiod=-0x80000000)\nMIDPRICE(high, low[, timeperiod=?])\n\nMidpoint Price over period (Overlap Studies)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_596stream_MIDPRICE, "stream_MIDPRICE(ndarray high, ndarray low, int timeperiod=-0x80000000)\n\nMIDPRICE(high, low[, timeperiod=?])\n\nMidpoint Price over period (Overlap Studies)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_597stream_MIDPRICE = {"stream_MIDPRICE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_597stream_MIDPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_596stream_MIDPRICE}; static PyObject *__pyx_pw_5talib_7_ta_lib_597stream_MIDPRICE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -73391,7 +72500,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3942, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3942, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -73410,7 +72519,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MIDPRICE", 0) < 0) __PYX_ERR(5, 3942, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MIDPRICE", 0) < (0)) __PYX_ERR(5, 3942, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MIDPRICE", 0, 2, 3, i); __PYX_ERR(5, 3942, __pyx_L3_error) } } @@ -73504,7 +72613,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_596stream_MIDPRICE(CYTHON_UNUSED PyObj __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 3968, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 3968, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -73545,7 +72654,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_598stream_MIN, "stream_MIN(ndarray real, int timeperiod=-0x80000000)\nMIN(real[, timeperiod=?])\n\nLowest value over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_598stream_MIN, "stream_MIN(ndarray real, int timeperiod=-0x80000000)\n\nMIN(real[, timeperiod=?])\n\nLowest value over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_599stream_MIN = {"stream_MIN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_599stream_MIN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_598stream_MIN}; static PyObject *__pyx_pw_5talib_7_ta_lib_599stream_MIN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -73578,7 +72687,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3974, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 3974, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -73593,7 +72702,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MIN", 0) < 0) __PYX_ERR(5, 3974, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MIN", 0) < (0)) __PYX_ERR(5, 3974, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MIN", 0, 1, 2, i); __PYX_ERR(5, 3974, __pyx_L3_error) } } @@ -73712,7 +72821,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_600stream_MININDEX, "stream_MININDEX(ndarray real, int timeperiod=-0x80000000)\nMININDEX(real[, timeperiod=?])\n\nIndex of lowest value over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n integer (values are -100, 0 or 100)"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_600stream_MININDEX, "stream_MININDEX(ndarray real, int timeperiod=-0x80000000)\n\nMININDEX(real[, timeperiod=?])\n\nIndex of lowest value over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n integer (values are -100, 0 or 100)"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_601stream_MININDEX = {"stream_MININDEX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_601stream_MININDEX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_600stream_MININDEX}; static PyObject *__pyx_pw_5talib_7_ta_lib_601stream_MININDEX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -73745,7 +72854,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4003, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4003, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -73760,7 +72869,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MININDEX", 0) < 0) __PYX_ERR(5, 4003, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MININDEX", 0) < (0)) __PYX_ERR(5, 4003, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MININDEX", 0, 1, 2, i); __PYX_ERR(5, 4003, __pyx_L3_error) } } @@ -73879,7 +72988,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_602stream_MINMAX, "stream_MINMAX(ndarray real, int timeperiod=-0x80000000)\nMINMAX(real[, timeperiod=?])\n\nLowest and highest values over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n min\n max"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_602stream_MINMAX, "stream_MINMAX(ndarray real, int timeperiod=-0x80000000)\n\nMINMAX(real[, timeperiod=?])\n\nLowest and highest values over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n min\n max"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_603stream_MINMAX = {"stream_MINMAX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_603stream_MINMAX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_602stream_MINMAX}; static PyObject *__pyx_pw_5talib_7_ta_lib_603stream_MINMAX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -73912,7 +73021,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4032, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4032, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -73927,7 +73036,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MINMAX", 0) < 0) __PYX_ERR(5, 4032, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MINMAX", 0) < (0)) __PYX_ERR(5, 4032, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MINMAX", 0, 1, 2, i); __PYX_ERR(5, 4032, __pyx_L3_error) } } @@ -74063,7 +73172,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_604stream_MINMAXINDEX, "stream_MINMAXINDEX(ndarray real, int timeperiod=-0x80000000)\nMINMAXINDEX(real[, timeperiod=?])\n\nIndexes of lowest and highest values over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n minidx\n maxidx"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_604stream_MINMAXINDEX, "stream_MINMAXINDEX(ndarray real, int timeperiod=-0x80000000)\n\nMINMAXINDEX(real[, timeperiod=?])\n\nIndexes of lowest and highest values over a specified period (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n minidx\n maxidx"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_605stream_MINMAXINDEX = {"stream_MINMAXINDEX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_605stream_MINMAXINDEX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_604stream_MINMAXINDEX}; static PyObject *__pyx_pw_5talib_7_ta_lib_605stream_MINMAXINDEX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -74096,7 +73205,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4064, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4064, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -74111,7 +73220,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MINMAXINDEX", 0) < 0) __PYX_ERR(5, 4064, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MINMAXINDEX", 0) < (0)) __PYX_ERR(5, 4064, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MINMAXINDEX", 0, 1, 2, i); __PYX_ERR(5, 4064, __pyx_L3_error) } } @@ -74247,7 +73356,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_606stream_MINUS_DI, "stream_MINUS_DI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\nMINUS_DI(high, low, close[, timeperiod=?])\n\nMinus Directional Indicator (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_606stream_MINUS_DI, "stream_MINUS_DI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nMINUS_DI(high, low, close[, timeperiod=?])\n\nMinus Directional Indicator (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_607stream_MINUS_DI = {"stream_MINUS_DI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_607stream_MINUS_DI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_606stream_MINUS_DI}; static PyObject *__pyx_pw_5talib_7_ta_lib_607stream_MINUS_DI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -74282,7 +73391,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4096, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4096, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -74305,7 +73414,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MINUS_DI", 0) < 0) __PYX_ERR(5, 4096, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MINUS_DI", 0) < (0)) __PYX_ERR(5, 4096, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MINUS_DI", 0, 3, 4, i); __PYX_ERR(5, 4096, __pyx_L3_error) } } @@ -74412,7 +73521,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_606stream_MINUS_DI(CYTHON_UNUSED PyObj __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4125, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 4125, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -74454,7 +73563,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_608stream_MINUS_DM, "stream_MINUS_DM(ndarray high, ndarray low, int timeperiod=-0x80000000)\nMINUS_DM(high, low[, timeperiod=?])\n\nMinus Directional Movement (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_608stream_MINUS_DM, "stream_MINUS_DM(ndarray high, ndarray low, int timeperiod=-0x80000000)\n\nMINUS_DM(high, low[, timeperiod=?])\n\nMinus Directional Movement (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_609stream_MINUS_DM = {"stream_MINUS_DM", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_609stream_MINUS_DM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_608stream_MINUS_DM}; static PyObject *__pyx_pw_5talib_7_ta_lib_609stream_MINUS_DM(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -74488,7 +73597,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4131, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4131, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -74507,7 +73616,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MINUS_DM", 0) < 0) __PYX_ERR(5, 4131, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MINUS_DM", 0) < (0)) __PYX_ERR(5, 4131, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MINUS_DM", 0, 2, 3, i); __PYX_ERR(5, 4131, __pyx_L3_error) } } @@ -74601,7 +73710,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_608stream_MINUS_DM(CYTHON_UNUSED PyObj __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4157, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 4157, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -74642,7 +73751,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_610stream_MOM, "stream_MOM(ndarray real, int timeperiod=-0x80000000)\nMOM(real[, timeperiod=?])\n\nMomentum (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 10\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_610stream_MOM, "stream_MOM(ndarray real, int timeperiod=-0x80000000)\n\nMOM(real[, timeperiod=?])\n\nMomentum (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 10\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_611stream_MOM = {"stream_MOM", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_611stream_MOM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_610stream_MOM}; static PyObject *__pyx_pw_5talib_7_ta_lib_611stream_MOM(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -74675,7 +73784,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4163, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4163, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -74690,7 +73799,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MOM", 0) < 0) __PYX_ERR(5, 4163, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MOM", 0) < (0)) __PYX_ERR(5, 4163, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MOM", 0, 1, 2, i); __PYX_ERR(5, 4163, __pyx_L3_error) } } @@ -74809,7 +73918,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_612stream_MULT, "stream_MULT(ndarray real0, ndarray real1)\nMULT(real0, real1)\n\nVector Arithmetic Mult (Math Operators)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_612stream_MULT, "stream_MULT(ndarray real0, ndarray real1)\n\nMULT(real0, real1)\n\nVector Arithmetic Mult (Math Operators)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_613stream_MULT = {"stream_MULT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_613stream_MULT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_612stream_MULT}; static PyObject *__pyx_pw_5talib_7_ta_lib_613stream_MULT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -74842,7 +73951,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4192, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4192, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -74857,7 +73966,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MULT", 0) < 0) __PYX_ERR(5, 4192, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MULT", 0) < (0)) __PYX_ERR(5, 4192, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MULT", 1, 2, 2, i); __PYX_ERR(5, 4192, __pyx_L3_error) } } @@ -74939,7 +74048,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_612stream_MULT(CYTHON_UNUSED PyObject __pyx_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4217, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 4217, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -74980,7 +74089,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_614stream_NATR, "stream_NATR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\nNATR(high, low, close[, timeperiod=?])\n\nNormalized Average True Range (Volatility Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_614stream_NATR, "stream_NATR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nNATR(high, low, close[, timeperiod=?])\n\nNormalized Average True Range (Volatility Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_615stream_NATR = {"stream_NATR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_615stream_NATR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_614stream_NATR}; static PyObject *__pyx_pw_5talib_7_ta_lib_615stream_NATR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -75015,7 +74124,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4223, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4223, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -75038,7 +74147,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_NATR", 0) < 0) __PYX_ERR(5, 4223, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_NATR", 0) < (0)) __PYX_ERR(5, 4223, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_NATR", 0, 3, 4, i); __PYX_ERR(5, 4223, __pyx_L3_error) } } @@ -75145,7 +74254,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_614stream_NATR(CYTHON_UNUSED PyObject __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4252, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 4252, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -75187,7 +74296,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_616stream_OBV, "stream_OBV(ndarray real, ndarray volume)\nOBV(real, volume)\n\nOn Balance Volume (Volume Indicators)\n\nInputs:\n real: (any ndarray)\n prices: ['volume']\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_616stream_OBV, "stream_OBV(ndarray real, ndarray volume)\n\nOBV(real, volume)\n\nOn Balance Volume (Volume Indicators)\n\nInputs:\n real: (any ndarray)\n prices: ['volume']\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_617stream_OBV = {"stream_OBV", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_617stream_OBV, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_616stream_OBV}; static PyObject *__pyx_pw_5talib_7_ta_lib_617stream_OBV(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -75220,7 +74329,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_volume,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4258, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4258, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -75235,7 +74344,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_OBV", 0) < 0) __PYX_ERR(5, 4258, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_OBV", 0) < (0)) __PYX_ERR(5, 4258, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_OBV", 1, 2, 2, i); __PYX_ERR(5, 4258, __pyx_L3_error) } } @@ -75317,7 +74426,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_616stream_OBV(CYTHON_UNUSED PyObject * __pyx_v_volume_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4283, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 4283, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -75358,7 +74467,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_618stream_PLUS_DI, "stream_PLUS_DI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\nPLUS_DI(high, low, close[, timeperiod=?])\n\nPlus Directional Indicator (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_618stream_PLUS_DI, "stream_PLUS_DI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nPLUS_DI(high, low, close[, timeperiod=?])\n\nPlus Directional Indicator (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_619stream_PLUS_DI = {"stream_PLUS_DI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_619stream_PLUS_DI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_618stream_PLUS_DI}; static PyObject *__pyx_pw_5talib_7_ta_lib_619stream_PLUS_DI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -75393,7 +74502,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4289, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4289, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -75416,7 +74525,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_PLUS_DI", 0) < 0) __PYX_ERR(5, 4289, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_PLUS_DI", 0) < (0)) __PYX_ERR(5, 4289, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_PLUS_DI", 0, 3, 4, i); __PYX_ERR(5, 4289, __pyx_L3_error) } } @@ -75523,7 +74632,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_618stream_PLUS_DI(CYTHON_UNUSED PyObje __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4318, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 4318, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -75565,7 +74674,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_620stream_PLUS_DM, "stream_PLUS_DM(ndarray high, ndarray low, int timeperiod=-0x80000000)\nPLUS_DM(high, low[, timeperiod=?])\n\nPlus Directional Movement (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_620stream_PLUS_DM, "stream_PLUS_DM(ndarray high, ndarray low, int timeperiod=-0x80000000)\n\nPLUS_DM(high, low[, timeperiod=?])\n\nPlus Directional Movement (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_621stream_PLUS_DM = {"stream_PLUS_DM", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_621stream_PLUS_DM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_620stream_PLUS_DM}; static PyObject *__pyx_pw_5talib_7_ta_lib_621stream_PLUS_DM(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -75599,7 +74708,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4324, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4324, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -75618,7 +74727,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_PLUS_DM", 0) < 0) __PYX_ERR(5, 4324, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_PLUS_DM", 0) < (0)) __PYX_ERR(5, 4324, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_PLUS_DM", 0, 2, 3, i); __PYX_ERR(5, 4324, __pyx_L3_error) } } @@ -75712,7 +74821,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_620stream_PLUS_DM(CYTHON_UNUSED PyObje __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4350, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 4350, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -75753,7 +74862,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_622stream_PPO, "stream_PPO(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int matype=0)\nPPO(real[, fastperiod=?, slowperiod=?, matype=?])\n\nPercentage Price Oscillator (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n fastperiod: 12\n slowperiod: 26\n matype: 0 (Simple Moving Average)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_622stream_PPO, "stream_PPO(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int matype=0)\n\nPPO(real[, fastperiod=?, slowperiod=?, matype=?])\n\nPercentage Price Oscillator (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n fastperiod: 12\n slowperiod: 26\n matype: 0 (Simple Moving Average)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_623stream_PPO = {"stream_PPO", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_623stream_PPO, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_622stream_PPO}; static PyObject *__pyx_pw_5talib_7_ta_lib_623stream_PPO(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -75788,7 +74897,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_fastperiod,&__pyx_mstate_global->__pyx_n_u_slowperiod,&__pyx_mstate_global->__pyx_n_u_matype,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4356, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4356, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -75811,7 +74920,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_PPO", 0) < 0) __PYX_ERR(5, 4356, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_PPO", 0) < (0)) __PYX_ERR(5, 4356, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_PPO", 0, 1, 4, i); __PYX_ERR(5, 4356, __pyx_L3_error) } } @@ -75948,7 +75057,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_624stream_ROC, "stream_ROC(ndarray real, int timeperiod=-0x80000000)\nROC(real[, timeperiod=?])\n\nRate of change : ((real/prevPrice)-1)*100 (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 10\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_624stream_ROC, "stream_ROC(ndarray real, int timeperiod=-0x80000000)\n\nROC(real[, timeperiod=?])\n\nRate of change : ((real/prevPrice)-1)*100 (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 10\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_625stream_ROC = {"stream_ROC", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_625stream_ROC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_624stream_ROC}; static PyObject *__pyx_pw_5talib_7_ta_lib_625stream_ROC(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -75981,7 +75090,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4387, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4387, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -75996,7 +75105,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ROC", 0) < 0) __PYX_ERR(5, 4387, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ROC", 0) < (0)) __PYX_ERR(5, 4387, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ROC", 0, 1, 2, i); __PYX_ERR(5, 4387, __pyx_L3_error) } } @@ -76115,7 +75224,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_626stream_ROCP, "stream_ROCP(ndarray real, int timeperiod=-0x80000000)\nROCP(real[, timeperiod=?])\n\nRate of change Percentage: (real-prevPrice)/prevPrice (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 10\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_626stream_ROCP, "stream_ROCP(ndarray real, int timeperiod=-0x80000000)\n\nROCP(real[, timeperiod=?])\n\nRate of change Percentage: (real-prevPrice)/prevPrice (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 10\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_627stream_ROCP = {"stream_ROCP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_627stream_ROCP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_626stream_ROCP}; static PyObject *__pyx_pw_5talib_7_ta_lib_627stream_ROCP(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -76148,7 +75257,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4416, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4416, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -76163,7 +75272,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ROCP", 0) < 0) __PYX_ERR(5, 4416, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ROCP", 0) < (0)) __PYX_ERR(5, 4416, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ROCP", 0, 1, 2, i); __PYX_ERR(5, 4416, __pyx_L3_error) } } @@ -76282,7 +75391,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_628stream_ROCR, "stream_ROCR(ndarray real, int timeperiod=-0x80000000)\nROCR(real[, timeperiod=?])\n\nRate of change ratio: (real/prevPrice) (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 10\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_628stream_ROCR, "stream_ROCR(ndarray real, int timeperiod=-0x80000000)\n\nROCR(real[, timeperiod=?])\n\nRate of change ratio: (real/prevPrice) (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 10\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_629stream_ROCR = {"stream_ROCR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_629stream_ROCR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_628stream_ROCR}; static PyObject *__pyx_pw_5talib_7_ta_lib_629stream_ROCR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -76315,7 +75424,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4445, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4445, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -76330,7 +75439,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ROCR", 0) < 0) __PYX_ERR(5, 4445, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ROCR", 0) < (0)) __PYX_ERR(5, 4445, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ROCR", 0, 1, 2, i); __PYX_ERR(5, 4445, __pyx_L3_error) } } @@ -76449,7 +75558,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_630stream_ROCR100, "stream_ROCR100(ndarray real, int timeperiod=-0x80000000)\nROCR100(real[, timeperiod=?])\n\nRate of change ratio 100 scale: (real/prevPrice)*100 (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 10\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_630stream_ROCR100, "stream_ROCR100(ndarray real, int timeperiod=-0x80000000)\n\nROCR100(real[, timeperiod=?])\n\nRate of change ratio 100 scale: (real/prevPrice)*100 (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 10\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_631stream_ROCR100 = {"stream_ROCR100", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_631stream_ROCR100, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_630stream_ROCR100}; static PyObject *__pyx_pw_5talib_7_ta_lib_631stream_ROCR100(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -76482,7 +75591,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4474, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4474, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -76497,7 +75606,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ROCR100", 0) < 0) __PYX_ERR(5, 4474, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ROCR100", 0) < (0)) __PYX_ERR(5, 4474, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ROCR100", 0, 1, 2, i); __PYX_ERR(5, 4474, __pyx_L3_error) } } @@ -76616,7 +75725,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_632stream_RSI, "stream_RSI(ndarray real, int timeperiod=-0x80000000)\nRSI(real[, timeperiod=?])\n\nRelative Strength Index (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_632stream_RSI, "stream_RSI(ndarray real, int timeperiod=-0x80000000)\n\nRSI(real[, timeperiod=?])\n\nRelative Strength Index (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_633stream_RSI = {"stream_RSI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_633stream_RSI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_632stream_RSI}; static PyObject *__pyx_pw_5talib_7_ta_lib_633stream_RSI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -76649,7 +75758,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4503, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4503, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -76664,7 +75773,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_RSI", 0) < 0) __PYX_ERR(5, 4503, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_RSI", 0) < (0)) __PYX_ERR(5, 4503, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_RSI", 0, 1, 2, i); __PYX_ERR(5, 4503, __pyx_L3_error) } } @@ -76783,7 +75892,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_634stream_SAR, "stream_SAR(ndarray high, ndarray low, double acceleration=0.02, double maximum=0.2)\nSAR(high, low[, acceleration=?, maximum=?])\n\nParabolic SAR (Overlap Studies)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n acceleration: 0.02\n maximum: 0.2\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_634stream_SAR, "stream_SAR(ndarray high, ndarray low, double acceleration=0.02, double maximum=0.2)\n\nSAR(high, low[, acceleration=?, maximum=?])\n\nParabolic SAR (Overlap Studies)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n acceleration: 0.02\n maximum: 0.2\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_635stream_SAR = {"stream_SAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_635stream_SAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_634stream_SAR}; static PyObject *__pyx_pw_5talib_7_ta_lib_635stream_SAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -76818,7 +75927,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_acceleration,&__pyx_mstate_global->__pyx_n_u_maximum,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4532, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4532, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -76841,7 +75950,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SAR", 0) < 0) __PYX_ERR(5, 4532, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SAR", 0) < (0)) __PYX_ERR(5, 4532, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_SAR", 0, 2, 4, i); __PYX_ERR(5, 4532, __pyx_L3_error) } } @@ -76944,7 +76053,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_634stream_SAR(CYTHON_UNUSED PyObject * __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4559, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 4559, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -76985,7 +76094,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_636stream_SAREXT, "stream_SAREXT(ndarray high, ndarray low, double startvalue=-4e37, double offsetonreverse=-4e37, double accelerationinitlong=-4e37, double accelerationlong=-4e37, double accelerationmaxlong=-4e37, double accelerationinitshort=-4e37, double accelerationshort=-4e37, double accelerationmaxshort=-4e37)\nSAREXT(high, low[, startvalue=?, offsetonreverse=?, accelerationinitlong=?, accelerationlong=?, accelerationmaxlong=?, accelerationinitshort=?, accelerationshort=?, accelerationmaxshort=?])\n\nParabolic SAR - Extended (Overlap Studies)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n startvalue: 0.0\n offsetonreverse: 0.0\n accelerationinitlong: 0.02\n accelerationlong: 0.02\n accelerationmaxlong: 0.2\n accelerationinitshort: 0.02\n accelerationshort: 0.02\n accelerationmaxshort: 0.2\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_636stream_SAREXT, "stream_SAREXT(ndarray high, ndarray low, double startvalue=-4e37, double offsetonreverse=-4e37, double accelerationinitlong=-4e37, double accelerationlong=-4e37, double accelerationmaxlong=-4e37, double accelerationinitshort=-4e37, double accelerationshort=-4e37, double accelerationmaxshort=-4e37)\n\nSAREXT(high, low[, startvalue=?, offsetonreverse=?, accelerationinitlong=?, accelerationlong=?, accelerationmaxlong=?, accelerationinitshort=?, accelerationshort=?, accelerationmaxshort=?])\n\nParabolic SAR - Extended (Overlap Studies)\n\nInputs:\n prices: ['high', 'low']\nParameters:\n startvalue: 0.0\n offsetonreverse: 0.0\n accelerationinitlong: 0.02\n accelerationlong: 0.02\n accelerationmaxlong: 0.2\n accelerationinitshort: 0.02\n accelerationshort: 0.02\n accelerationmaxshort: 0.2\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_637stream_SAREXT = {"stream_SAREXT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_637stream_SAREXT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_636stream_SAREXT}; static PyObject *__pyx_pw_5talib_7_ta_lib_637stream_SAREXT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -77026,7 +76135,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_startvalue,&__pyx_mstate_global->__pyx_n_u_offsetonreverse,&__pyx_mstate_global->__pyx_n_u_accelerationinitlong,&__pyx_mstate_global->__pyx_n_u_accelerationlong,&__pyx_mstate_global->__pyx_n_u_accelerationmaxlong,&__pyx_mstate_global->__pyx_n_u_accelerationinitshort,&__pyx_mstate_global->__pyx_n_u_accelerationshort,&__pyx_mstate_global->__pyx_n_u_accelerationmaxshort,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4565, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4565, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 10: @@ -77073,7 +76182,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SAREXT", 0) < 0) __PYX_ERR(5, 4565, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SAREXT", 0) < (0)) __PYX_ERR(5, 4565, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_SAREXT", 0, 2, 10, i); __PYX_ERR(5, 4565, __pyx_L3_error) } } @@ -77230,7 +76339,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_636stream_SAREXT(CYTHON_UNUSED PyObjec __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4598, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 4598, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -77271,7 +76380,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_638stream_SIN, "stream_SIN(ndarray real)\nSIN(real)\n\nVector Trigonometric Sin (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_638stream_SIN, "stream_SIN(ndarray real)\n\nSIN(real)\n\nVector Trigonometric Sin (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_639stream_SIN = {"stream_SIN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_639stream_SIN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_638stream_SIN}; static PyObject *__pyx_pw_5talib_7_ta_lib_639stream_SIN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -77303,7 +76412,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4604, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4604, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -77314,7 +76423,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SIN", 0) < 0) __PYX_ERR(5, 4604, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SIN", 0) < (0)) __PYX_ERR(5, 4604, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_SIN", 1, 1, 1, i); __PYX_ERR(5, 4604, __pyx_L3_error) } } @@ -77421,7 +76530,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_640stream_SINH, "stream_SINH(ndarray real)\nSINH(real)\n\nVector Trigonometric Sinh (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_640stream_SINH, "stream_SINH(ndarray real)\n\nSINH(real)\n\nVector Trigonometric Sinh (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_641stream_SINH = {"stream_SINH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_641stream_SINH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_640stream_SINH}; static PyObject *__pyx_pw_5talib_7_ta_lib_641stream_SINH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -77453,7 +76562,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4631, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4631, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -77464,7 +76573,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SINH", 0) < 0) __PYX_ERR(5, 4631, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SINH", 0) < (0)) __PYX_ERR(5, 4631, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_SINH", 1, 1, 1, i); __PYX_ERR(5, 4631, __pyx_L3_error) } } @@ -77571,7 +76680,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_642stream_SMA, "stream_SMA(ndarray real, int timeperiod=-0x80000000)\nSMA(real[, timeperiod=?])\n\nSimple Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_642stream_SMA, "stream_SMA(ndarray real, int timeperiod=-0x80000000)\n\nSMA(real[, timeperiod=?])\n\nSimple Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_643stream_SMA = {"stream_SMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_643stream_SMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_642stream_SMA}; static PyObject *__pyx_pw_5talib_7_ta_lib_643stream_SMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -77604,7 +76713,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4658, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4658, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -77619,7 +76728,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SMA", 0) < 0) __PYX_ERR(5, 4658, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SMA", 0) < (0)) __PYX_ERR(5, 4658, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_SMA", 0, 1, 2, i); __PYX_ERR(5, 4658, __pyx_L3_error) } } @@ -77738,7 +76847,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_644stream_SQRT, "stream_SQRT(ndarray real)\nSQRT(real)\n\nVector Square Root (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_644stream_SQRT, "stream_SQRT(ndarray real)\n\nSQRT(real)\n\nVector Square Root (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_645stream_SQRT = {"stream_SQRT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_645stream_SQRT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_644stream_SQRT}; static PyObject *__pyx_pw_5talib_7_ta_lib_645stream_SQRT(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -77770,7 +76879,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4687, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4687, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -77781,7 +76890,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SQRT", 0) < 0) __PYX_ERR(5, 4687, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SQRT", 0) < (0)) __PYX_ERR(5, 4687, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_SQRT", 1, 1, 1, i); __PYX_ERR(5, 4687, __pyx_L3_error) } } @@ -77888,7 +76997,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_646stream_STDDEV, "stream_STDDEV(ndarray real, int timeperiod=-0x80000000, double nbdev=-4e37)\nSTDDEV(real[, timeperiod=?, nbdev=?])\n\nStandard Deviation (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 5\n nbdev: 1.0\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_646stream_STDDEV, "stream_STDDEV(ndarray real, int timeperiod=-0x80000000, double nbdev=-4e37)\n\nSTDDEV(real[, timeperiod=?, nbdev=?])\n\nStandard Deviation (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 5\n nbdev: 1.0\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_647stream_STDDEV = {"stream_STDDEV", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_647stream_STDDEV, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_646stream_STDDEV}; static PyObject *__pyx_pw_5talib_7_ta_lib_647stream_STDDEV(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -77922,7 +77031,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_nbdev,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4714, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4714, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -77941,7 +77050,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_STDDEV", 0) < 0) __PYX_ERR(5, 4714, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_STDDEV", 0) < (0)) __PYX_ERR(5, 4714, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_STDDEV", 0, 1, 3, i); __PYX_ERR(5, 4714, __pyx_L3_error) } } @@ -78069,7 +77178,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_648stream_STOCH, "stream_STOCH(ndarray high, ndarray low, ndarray close, int fastk_period=-0x80000000, int slowk_period=-0x80000000, int slowk_matype=0, int slowd_period=-0x80000000, int slowd_matype=0)\nSTOCH(high, low, close[, fastk_period=?, slowk_period=?, slowk_matype=?, slowd_period=?, slowd_matype=?])\n\nStochastic (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n fastk_period: 5\n slowk_period: 3\n slowk_matype: 0\n slowd_period: 3\n slowd_matype: 0\nOutputs:\n slowk\n slowd"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_648stream_STOCH, "stream_STOCH(ndarray high, ndarray low, ndarray close, int fastk_period=-0x80000000, int slowk_period=-0x80000000, int slowk_matype=0, int slowd_period=-0x80000000, int slowd_matype=0)\n\nSTOCH(high, low, close[, fastk_period=?, slowk_period=?, slowk_matype=?, slowd_period=?, slowd_matype=?])\n\nStochastic (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n fastk_period: 5\n slowk_period: 3\n slowk_matype: 0\n slowd_period: 3\n slowd_matype: 0\nOutputs:\n slowk\n slowd"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_649stream_STOCH = {"stream_STOCH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_649stream_STOCH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_648stream_STOCH}; static PyObject *__pyx_pw_5talib_7_ta_lib_649stream_STOCH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -78108,7 +77217,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_fastk_period,&__pyx_mstate_global->__pyx_n_u_slowk_period,&__pyx_mstate_global->__pyx_n_u_slowk_matype,&__pyx_mstate_global->__pyx_n_u_slowd_period,&__pyx_mstate_global->__pyx_n_u_slowd_matype,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4744, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4744, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 8: @@ -78147,7 +77256,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_STOCH", 0) < 0) __PYX_ERR(5, 4744, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_STOCH", 0) < (0)) __PYX_ERR(5, 4744, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_STOCH", 0, 3, 8, i); __PYX_ERR(5, 4744, __pyx_L3_error) } } @@ -78293,7 +77402,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_648stream_STOCH(CYTHON_UNUSED PyObject __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4779, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 4779, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outslowk = __pyx_v_5talib_7_ta_lib_NaN; @@ -78349,7 +77458,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_650stream_STOCHF, "stream_STOCHF(ndarray high, ndarray low, ndarray close, int fastk_period=-0x80000000, int fastd_period=-0x80000000, int fastd_matype=0)\nSTOCHF(high, low, close[, fastk_period=?, fastd_period=?, fastd_matype=?])\n\nStochastic Fast (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n fastk_period: 5\n fastd_period: 3\n fastd_matype: 0\nOutputs:\n fastk\n fastd"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_650stream_STOCHF, "stream_STOCHF(ndarray high, ndarray low, ndarray close, int fastk_period=-0x80000000, int fastd_period=-0x80000000, int fastd_matype=0)\n\nSTOCHF(high, low, close[, fastk_period=?, fastd_period=?, fastd_matype=?])\n\nStochastic Fast (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n fastk_period: 5\n fastd_period: 3\n fastd_matype: 0\nOutputs:\n fastk\n fastd"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_651stream_STOCHF = {"stream_STOCHF", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_651stream_STOCHF, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_650stream_STOCHF}; static PyObject *__pyx_pw_5talib_7_ta_lib_651stream_STOCHF(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -78386,7 +77495,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_fastk_period,&__pyx_mstate_global->__pyx_n_u_fastd_period,&__pyx_mstate_global->__pyx_n_u_fastd_matype,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4786, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4786, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 6: @@ -78417,7 +77526,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_STOCHF", 0) < 0) __PYX_ERR(5, 4786, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_STOCHF", 0) < (0)) __PYX_ERR(5, 4786, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_STOCHF", 0, 3, 6, i); __PYX_ERR(5, 4786, __pyx_L3_error) } } @@ -78545,7 +77654,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_650stream_STOCHF(CYTHON_UNUSED PyObjec __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4819, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 4819, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outfastk = __pyx_v_5talib_7_ta_lib_NaN; @@ -78601,7 +77710,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_652stream_STOCHRSI, "stream_STOCHRSI(ndarray real, int timeperiod=-0x80000000, int fastk_period=-0x80000000, int fastd_period=-0x80000000, int fastd_matype=0)\nSTOCHRSI(real[, timeperiod=?, fastk_period=?, fastd_period=?, fastd_matype=?])\n\nStochastic Relative Strength Index (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\n fastk_period: 5\n fastd_period: 3\n fastd_matype: 0\nOutputs:\n fastk\n fastd"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_652stream_STOCHRSI, "stream_STOCHRSI(ndarray real, int timeperiod=-0x80000000, int fastk_period=-0x80000000, int fastd_period=-0x80000000, int fastd_matype=0)\n\nSTOCHRSI(real[, timeperiod=?, fastk_period=?, fastd_period=?, fastd_matype=?])\n\nStochastic Relative Strength Index (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\n fastk_period: 5\n fastd_period: 3\n fastd_matype: 0\nOutputs:\n fastk\n fastd"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_653stream_STOCHRSI = {"stream_STOCHRSI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_653stream_STOCHRSI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_652stream_STOCHRSI}; static PyObject *__pyx_pw_5talib_7_ta_lib_653stream_STOCHRSI(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -78637,7 +77746,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_fastk_period,&__pyx_mstate_global->__pyx_n_u_fastd_period,&__pyx_mstate_global->__pyx_n_u_fastd_matype,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4826, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4826, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 5: @@ -78664,7 +77773,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_STOCHRSI", 0) < 0) __PYX_ERR(5, 4826, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_STOCHRSI", 0) < (0)) __PYX_ERR(5, 4826, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_STOCHRSI", 0, 1, 5, i); __PYX_ERR(5, 4826, __pyx_L3_error) } } @@ -78827,7 +77936,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_654stream_SUB, "stream_SUB(ndarray real0, ndarray real1)\nSUB(real0, real1)\n\nVector Arithmetic Subtraction (Math Operators)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_654stream_SUB, "stream_SUB(ndarray real0, ndarray real1)\n\nSUB(real0, real1)\n\nVector Arithmetic Subtraction (Math Operators)\n\nInputs:\n real0: (any ndarray)\n real1: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_655stream_SUB = {"stream_SUB", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_655stream_SUB, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_654stream_SUB}; static PyObject *__pyx_pw_5talib_7_ta_lib_655stream_SUB(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -78860,7 +77969,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4861, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4861, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -78875,7 +77984,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SUB", 0) < 0) __PYX_ERR(5, 4861, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SUB", 0) < (0)) __PYX_ERR(5, 4861, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_SUB", 1, 2, 2, i); __PYX_ERR(5, 4861, __pyx_L3_error) } } @@ -78957,7 +78066,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_654stream_SUB(CYTHON_UNUSED PyObject * __pyx_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4886, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 4886, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -78998,7 +78107,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_656stream_SUM, "stream_SUM(ndarray real, int timeperiod=-0x80000000)\nSUM(real[, timeperiod=?])\n\nSummation (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_656stream_SUM, "stream_SUM(ndarray real, int timeperiod=-0x80000000)\n\nSUM(real[, timeperiod=?])\n\nSummation (Math Operators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_657stream_SUM = {"stream_SUM", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_657stream_SUM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_656stream_SUM}; static PyObject *__pyx_pw_5talib_7_ta_lib_657stream_SUM(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -79031,7 +78140,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4892, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4892, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -79046,7 +78155,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SUM", 0) < 0) __PYX_ERR(5, 4892, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SUM", 0) < (0)) __PYX_ERR(5, 4892, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_SUM", 0, 1, 2, i); __PYX_ERR(5, 4892, __pyx_L3_error) } } @@ -79165,7 +78274,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_658stream_T3, "stream_T3(ndarray real, int timeperiod=-0x80000000, double vfactor=-4e37)\nT3(real[, timeperiod=?, vfactor=?])\n\nTriple Exponential Moving Average (T3) (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 5\n vfactor: 0.7\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_658stream_T3, "stream_T3(ndarray real, int timeperiod=-0x80000000, double vfactor=-4e37)\n\nT3(real[, timeperiod=?, vfactor=?])\n\nTriple Exponential Moving Average (T3) (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 5\n vfactor: 0.7\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_659stream_T3 = {"stream_T3", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_659stream_T3, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_658stream_T3}; static PyObject *__pyx_pw_5talib_7_ta_lib_659stream_T3(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -79199,7 +78308,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_vfactor,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4921, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4921, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -79218,7 +78327,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_T3", 0) < 0) __PYX_ERR(5, 4921, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_T3", 0) < (0)) __PYX_ERR(5, 4921, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_T3", 0, 1, 3, i); __PYX_ERR(5, 4921, __pyx_L3_error) } } @@ -79346,7 +78455,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_660stream_TAN, "stream_TAN(ndarray real)\nTAN(real)\n\nVector Trigonometric Tan (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_660stream_TAN, "stream_TAN(ndarray real)\n\nTAN(real)\n\nVector Trigonometric Tan (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_661stream_TAN = {"stream_TAN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_661stream_TAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_660stream_TAN}; static PyObject *__pyx_pw_5talib_7_ta_lib_661stream_TAN(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -79378,7 +78487,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4951, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4951, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -79389,7 +78498,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TAN", 0) < 0) __PYX_ERR(5, 4951, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TAN", 0) < (0)) __PYX_ERR(5, 4951, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_TAN", 1, 1, 1, i); __PYX_ERR(5, 4951, __pyx_L3_error) } } @@ -79496,7 +78605,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_662stream_TANH, "stream_TANH(ndarray real)\nTANH(real)\n\nVector Trigonometric Tanh (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_662stream_TANH, "stream_TANH(ndarray real)\n\nTANH(real)\n\nVector Trigonometric Tanh (Math Transform)\n\nInputs:\n real: (any ndarray)\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_663stream_TANH = {"stream_TANH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_663stream_TANH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_662stream_TANH}; static PyObject *__pyx_pw_5talib_7_ta_lib_663stream_TANH(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -79528,7 +78637,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4978, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 4978, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 1: @@ -79539,7 +78648,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TANH", 0) < 0) __PYX_ERR(5, 4978, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TANH", 0) < (0)) __PYX_ERR(5, 4978, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_TANH", 1, 1, 1, i); __PYX_ERR(5, 4978, __pyx_L3_error) } } @@ -79646,7 +78755,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_664stream_TEMA, "stream_TEMA(ndarray real, int timeperiod=-0x80000000)\nTEMA(real[, timeperiod=?])\n\nTriple Exponential Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_664stream_TEMA, "stream_TEMA(ndarray real, int timeperiod=-0x80000000)\n\nTEMA(real[, timeperiod=?])\n\nTriple Exponential Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_665stream_TEMA = {"stream_TEMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_665stream_TEMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_664stream_TEMA}; static PyObject *__pyx_pw_5talib_7_ta_lib_665stream_TEMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -79679,7 +78788,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 5005, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 5005, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -79694,7 +78803,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TEMA", 0) < 0) __PYX_ERR(5, 5005, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TEMA", 0) < (0)) __PYX_ERR(5, 5005, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_TEMA", 0, 1, 2, i); __PYX_ERR(5, 5005, __pyx_L3_error) } } @@ -79813,7 +78922,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_666stream_TRANGE, "stream_TRANGE(ndarray high, ndarray low, ndarray close)\nTRANGE(high, low, close)\n\nTrue Range (Volatility Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_666stream_TRANGE, "stream_TRANGE(ndarray high, ndarray low, ndarray close)\n\nTRANGE(high, low, close)\n\nTrue Range (Volatility Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_667stream_TRANGE = {"stream_TRANGE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_667stream_TRANGE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_666stream_TRANGE}; static PyObject *__pyx_pw_5talib_7_ta_lib_667stream_TRANGE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -79847,7 +78956,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 5034, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 5034, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -79866,7 +78975,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TRANGE", 0) < 0) __PYX_ERR(5, 5034, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TRANGE", 0) < (0)) __PYX_ERR(5, 5034, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_TRANGE", 1, 3, 3, i); __PYX_ERR(5, 5034, __pyx_L3_error) } } @@ -79961,7 +79070,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_666stream_TRANGE(CYTHON_UNUSED PyObjec __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 5061, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 5061, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -80003,7 +79112,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_668stream_TRIMA, "stream_TRIMA(ndarray real, int timeperiod=-0x80000000)\nTRIMA(real[, timeperiod=?])\n\nTriangular Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_668stream_TRIMA, "stream_TRIMA(ndarray real, int timeperiod=-0x80000000)\n\nTRIMA(real[, timeperiod=?])\n\nTriangular Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_669stream_TRIMA = {"stream_TRIMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_669stream_TRIMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_668stream_TRIMA}; static PyObject *__pyx_pw_5talib_7_ta_lib_669stream_TRIMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -80036,7 +79145,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 5067, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 5067, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -80051,7 +79160,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TRIMA", 0) < 0) __PYX_ERR(5, 5067, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TRIMA", 0) < (0)) __PYX_ERR(5, 5067, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_TRIMA", 0, 1, 2, i); __PYX_ERR(5, 5067, __pyx_L3_error) } } @@ -80170,7 +79279,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_670stream_TRIX, "stream_TRIX(ndarray real, int timeperiod=-0x80000000)\nTRIX(real[, timeperiod=?])\n\n1-day Rate-Of-Change (ROC) of a Triple Smooth EMA (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_670stream_TRIX, "stream_TRIX(ndarray real, int timeperiod=-0x80000000)\n\nTRIX(real[, timeperiod=?])\n\n1-day Rate-Of-Change (ROC) of a Triple Smooth EMA (Momentum Indicators)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_671stream_TRIX = {"stream_TRIX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_671stream_TRIX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_670stream_TRIX}; static PyObject *__pyx_pw_5talib_7_ta_lib_671stream_TRIX(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -80203,7 +79312,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 5096, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 5096, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -80218,7 +79327,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TRIX", 0) < 0) __PYX_ERR(5, 5096, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TRIX", 0) < (0)) __PYX_ERR(5, 5096, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_TRIX", 0, 1, 2, i); __PYX_ERR(5, 5096, __pyx_L3_error) } } @@ -80337,7 +79446,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_672stream_TSF, "stream_TSF(ndarray real, int timeperiod=-0x80000000)\nTSF(real[, timeperiod=?])\n\nTime Series Forecast (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_672stream_TSF, "stream_TSF(ndarray real, int timeperiod=-0x80000000)\n\nTSF(real[, timeperiod=?])\n\nTime Series Forecast (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_673stream_TSF = {"stream_TSF", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_673stream_TSF, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_672stream_TSF}; static PyObject *__pyx_pw_5talib_7_ta_lib_673stream_TSF(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -80370,7 +79479,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 5125, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 5125, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -80385,7 +79494,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TSF", 0) < 0) __PYX_ERR(5, 5125, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TSF", 0) < (0)) __PYX_ERR(5, 5125, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_TSF", 0, 1, 2, i); __PYX_ERR(5, 5125, __pyx_L3_error) } } @@ -80504,7 +79613,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_674stream_TYPPRICE, "stream_TYPPRICE(ndarray high, ndarray low, ndarray close)\nTYPPRICE(high, low, close)\n\nTypical Price (Price Transform)\n\nInputs:\n prices: ['high', 'low', 'close']\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_674stream_TYPPRICE, "stream_TYPPRICE(ndarray high, ndarray low, ndarray close)\n\nTYPPRICE(high, low, close)\n\nTypical Price (Price Transform)\n\nInputs:\n prices: ['high', 'low', 'close']\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_675stream_TYPPRICE = {"stream_TYPPRICE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_675stream_TYPPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_674stream_TYPPRICE}; static PyObject *__pyx_pw_5talib_7_ta_lib_675stream_TYPPRICE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -80538,7 +79647,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 5154, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 5154, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -80557,7 +79666,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TYPPRICE", 0) < 0) __PYX_ERR(5, 5154, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TYPPRICE", 0) < (0)) __PYX_ERR(5, 5154, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_TYPPRICE", 1, 3, 3, i); __PYX_ERR(5, 5154, __pyx_L3_error) } } @@ -80652,7 +79761,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_674stream_TYPPRICE(CYTHON_UNUSED PyObj __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 5181, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 5181, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -80694,7 +79803,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_676stream_ULTOSC, "stream_ULTOSC(ndarray high, ndarray low, ndarray close, int timeperiod1=-0x80000000, int timeperiod2=-0x80000000, int timeperiod3=-0x80000000)\nULTOSC(high, low, close[, timeperiod1=?, timeperiod2=?, timeperiod3=?])\n\nUltimate Oscillator (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod1: 7\n timeperiod2: 14\n timeperiod3: 28\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_676stream_ULTOSC, "stream_ULTOSC(ndarray high, ndarray low, ndarray close, int timeperiod1=-0x80000000, int timeperiod2=-0x80000000, int timeperiod3=-0x80000000)\n\nULTOSC(high, low, close[, timeperiod1=?, timeperiod2=?, timeperiod3=?])\n\nUltimate Oscillator (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod1: 7\n timeperiod2: 14\n timeperiod3: 28\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_677stream_ULTOSC = {"stream_ULTOSC", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_677stream_ULTOSC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_676stream_ULTOSC}; static PyObject *__pyx_pw_5talib_7_ta_lib_677stream_ULTOSC(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -80731,7 +79840,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod1,&__pyx_mstate_global->__pyx_n_u_timeperiod2,&__pyx_mstate_global->__pyx_n_u_timeperiod3,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 5187, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 5187, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 6: @@ -80762,7 +79871,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ULTOSC", 0) < 0) __PYX_ERR(5, 5187, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ULTOSC", 0) < (0)) __PYX_ERR(5, 5187, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ULTOSC", 0, 3, 6, i); __PYX_ERR(5, 5187, __pyx_L3_error) } } @@ -80887,7 +79996,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_676stream_ULTOSC(CYTHON_UNUSED PyObjec __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 5218, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 5218, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -80929,7 +80038,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_678stream_VAR, "stream_VAR(ndarray real, int timeperiod=-0x80000000, double nbdev=-4e37)\nVAR(real[, timeperiod=?, nbdev=?])\n\nVariance (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 5\n nbdev: 1.0\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_678stream_VAR, "stream_VAR(ndarray real, int timeperiod=-0x80000000, double nbdev=-4e37)\n\nVAR(real[, timeperiod=?, nbdev=?])\n\nVariance (Statistic Functions)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 5\n nbdev: 1.0\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_679stream_VAR = {"stream_VAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_679stream_VAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_678stream_VAR}; static PyObject *__pyx_pw_5talib_7_ta_lib_679stream_VAR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -80963,7 +80072,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_nbdev,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 5224, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 5224, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -80982,7 +80091,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_VAR", 0) < 0) __PYX_ERR(5, 5224, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_VAR", 0) < (0)) __PYX_ERR(5, 5224, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_VAR", 0, 1, 3, i); __PYX_ERR(5, 5224, __pyx_L3_error) } } @@ -81110,7 +80219,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_680stream_WCLPRICE, "stream_WCLPRICE(ndarray high, ndarray low, ndarray close)\nWCLPRICE(high, low, close)\n\nWeighted Close Price (Price Transform)\n\nInputs:\n prices: ['high', 'low', 'close']\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_680stream_WCLPRICE, "stream_WCLPRICE(ndarray high, ndarray low, ndarray close)\n\nWCLPRICE(high, low, close)\n\nWeighted Close Price (Price Transform)\n\nInputs:\n prices: ['high', 'low', 'close']\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_681stream_WCLPRICE = {"stream_WCLPRICE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_681stream_WCLPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_680stream_WCLPRICE}; static PyObject *__pyx_pw_5talib_7_ta_lib_681stream_WCLPRICE(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -81144,7 +80253,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 5254, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 5254, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 3: @@ -81163,7 +80272,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_WCLPRICE", 0) < 0) __PYX_ERR(5, 5254, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_WCLPRICE", 0) < (0)) __PYX_ERR(5, 5254, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_WCLPRICE", 1, 3, 3, i); __PYX_ERR(5, 5254, __pyx_L3_error) } } @@ -81258,7 +80367,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_680stream_WCLPRICE(CYTHON_UNUSED PyObj __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 5281, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 5281, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -81300,7 +80409,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_682stream_WILLR, "stream_WILLR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\nWILLR(high, low, close[, timeperiod=?])\n\nWilliams' %R (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_682stream_WILLR, "stream_WILLR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nWILLR(high, low, close[, timeperiod=?])\n\nWilliams' %R (Momentum Indicators)\n\nInputs:\n prices: ['high', 'low', 'close']\nParameters:\n timeperiod: 14\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_683stream_WILLR = {"stream_WILLR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_683stream_WILLR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_682stream_WILLR}; static PyObject *__pyx_pw_5talib_7_ta_lib_683stream_WILLR(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -81335,7 +80444,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 5287, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 5287, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 4: @@ -81358,7 +80467,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_WILLR", 0) < 0) __PYX_ERR(5, 5287, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_WILLR", 0) < (0)) __PYX_ERR(5, 5287, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_WILLR", 0, 3, 4, i); __PYX_ERR(5, 5287, __pyx_L3_error) } } @@ -81465,7 +80574,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_682stream_WILLR(CYTHON_UNUSED PyObject __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); - __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 5316, __pyx_L1_error) + __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 5316, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; @@ -81507,7 +80616,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_684stream_WMA, "stream_WMA(ndarray real, int timeperiod=-0x80000000)\nWMA(real[, timeperiod=?])\n\nWeighted Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); +PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_684stream_WMA, "stream_WMA(ndarray real, int timeperiod=-0x80000000)\n\nWMA(real[, timeperiod=?])\n\nWeighted Moving Average (Overlap Studies)\n\nInputs:\n real: (any ndarray)\nParameters:\n timeperiod: 30\nOutputs:\n real"); static PyMethodDef __pyx_mdef_5talib_7_ta_lib_685stream_WMA = {"stream_WMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_685stream_WMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_684stream_WMA}; static PyObject *__pyx_pw_5talib_7_ta_lib_685stream_WMA(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL @@ -81540,7 +80649,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds { PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0}; const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; - if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 5322, __pyx_L3_error) + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(5, 5322, __pyx_L3_error) if (__pyx_kwds_len > 0) { switch (__pyx_nargs) { case 2: @@ -81555,7 +80664,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_WMA", 0) < 0) __PYX_ERR(5, 5322, __pyx_L3_error) + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_WMA", 0) < (0)) __PYX_ERR(5, 5322, __pyx_L3_error) for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_WMA", 0, 1, 2, i); __PYX_ERR(5, 5322, __pyx_L3_error) } } @@ -81731,153 +80840,153 @@ static int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate) { /*--- Type import code ---*/ __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_mstate->__pyx_ptype_7cpython_4type_type = __Pyx_ImportType_3_1_1(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", + __pyx_mstate->__pyx_ptype_7cpython_4type_type = __Pyx_ImportType_3_2_8(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyTypeObject), + sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyTypeObject), #elif CYTHON_COMPILING_IN_LIMITED_API 0, 0, #else - sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyHeapTypeObject), + sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyHeapTypeObject), #endif - __Pyx_ImportType_CheckSize_Warn_3_1_1); if (!__pyx_mstate->__pyx_ptype_7cpython_4type_type) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_ImportType_CheckSize_Warn_3_2_8); if (!__pyx_mstate->__pyx_ptype_7cpython_4type_type) __PYX_ERR(6, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 228, __pyx_L1_error) + __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_mstate->__pyx_ptype_5numpy_dtype = __Pyx_ImportType_3_1_1(__pyx_t_1, "numpy", "dtype", + __pyx_mstate->__pyx_ptype_5numpy_dtype = __Pyx_ImportType_3_2_8(__pyx_t_1, "numpy", "dtype", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyArray_Descr), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyArray_Descr), + sizeof(PyArray_Descr), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyArray_Descr), #elif CYTHON_COMPILING_IN_LIMITED_API - sizeof(PyArray_Descr), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyArray_Descr), + sizeof(PyArray_Descr), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyArray_Descr), #else - sizeof(PyArray_Descr), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyArray_Descr), + sizeof(PyArray_Descr), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyArray_Descr), #endif - __Pyx_ImportType_CheckSize_Ignore_3_1_1); if (!__pyx_mstate->__pyx_ptype_5numpy_dtype) __PYX_ERR(3, 228, __pyx_L1_error) - __pyx_mstate->__pyx_ptype_5numpy_flatiter = __Pyx_ImportType_3_1_1(__pyx_t_1, "numpy", "flatiter", + __Pyx_ImportType_CheckSize_Ignore_3_2_8); if (!__pyx_mstate->__pyx_ptype_5numpy_dtype) __PYX_ERR(3, 229, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_flatiter = __Pyx_ImportType_3_2_8(__pyx_t_1, "numpy", "flatiter", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyArrayIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyArrayIterObject), + sizeof(PyArrayIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyArrayIterObject), #elif CYTHON_COMPILING_IN_LIMITED_API - sizeof(PyArrayIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyArrayIterObject), + sizeof(PyArrayIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyArrayIterObject), #else - sizeof(PyArrayIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyArrayIterObject), + sizeof(PyArrayIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyArrayIterObject), #endif - __Pyx_ImportType_CheckSize_Ignore_3_1_1); if (!__pyx_mstate->__pyx_ptype_5numpy_flatiter) __PYX_ERR(3, 273, __pyx_L1_error) - __pyx_mstate->__pyx_ptype_5numpy_broadcast = __Pyx_ImportType_3_1_1(__pyx_t_1, "numpy", "broadcast", + __Pyx_ImportType_CheckSize_Ignore_3_2_8); if (!__pyx_mstate->__pyx_ptype_5numpy_flatiter) __PYX_ERR(3, 286, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_broadcast = __Pyx_ImportType_3_2_8(__pyx_t_1, "numpy", "broadcast", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyArrayMultiIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyArrayMultiIterObject), + sizeof(PyArrayMultiIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyArrayMultiIterObject), #elif CYTHON_COMPILING_IN_LIMITED_API - sizeof(PyArrayMultiIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyArrayMultiIterObject), + sizeof(PyArrayMultiIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyArrayMultiIterObject), #else - sizeof(PyArrayMultiIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyArrayMultiIterObject), + sizeof(PyArrayMultiIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyArrayMultiIterObject), #endif - __Pyx_ImportType_CheckSize_Ignore_3_1_1); if (!__pyx_mstate->__pyx_ptype_5numpy_broadcast) __PYX_ERR(3, 277, __pyx_L1_error) - __pyx_mstate->__pyx_ptype_5numpy_ndarray = __Pyx_ImportType_3_1_1(__pyx_t_1, "numpy", "ndarray", + __Pyx_ImportType_CheckSize_Ignore_3_2_8); if (!__pyx_mstate->__pyx_ptype_5numpy_broadcast) __PYX_ERR(3, 290, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_ndarray = __Pyx_ImportType_3_2_8(__pyx_t_1, "numpy", "ndarray", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyArrayObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyArrayObject), + sizeof(PyArrayObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyArrayObject), #elif CYTHON_COMPILING_IN_LIMITED_API - sizeof(PyArrayObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyArrayObject), + sizeof(PyArrayObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyArrayObject), #else - sizeof(PyArrayObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyArrayObject), + sizeof(PyArrayObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyArrayObject), #endif - __Pyx_ImportType_CheckSize_Ignore_3_1_1); if (!__pyx_mstate->__pyx_ptype_5numpy_ndarray) __PYX_ERR(3, 316, __pyx_L1_error) - __pyx_mstate->__pyx_ptype_5numpy_generic = __Pyx_ImportType_3_1_1(__pyx_t_1, "numpy", "generic", + __Pyx_ImportType_CheckSize_Ignore_3_2_8); if (!__pyx_mstate->__pyx_ptype_5numpy_ndarray) __PYX_ERR(3, 329, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_generic = __Pyx_ImportType_3_2_8(__pyx_t_1, "numpy", "generic", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #elif CYTHON_COMPILING_IN_LIMITED_API - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #else - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #endif - __Pyx_ImportType_CheckSize_Warn_3_1_1); if (!__pyx_mstate->__pyx_ptype_5numpy_generic) __PYX_ERR(3, 825, __pyx_L1_error) - __pyx_mstate->__pyx_ptype_5numpy_number = __Pyx_ImportType_3_1_1(__pyx_t_1, "numpy", "number", + __Pyx_ImportType_CheckSize_Warn_3_2_8); if (!__pyx_mstate->__pyx_ptype_5numpy_generic) __PYX_ERR(3, 847, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_number = __Pyx_ImportType_3_2_8(__pyx_t_1, "numpy", "number", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #elif CYTHON_COMPILING_IN_LIMITED_API - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #else - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #endif - __Pyx_ImportType_CheckSize_Warn_3_1_1); if (!__pyx_mstate->__pyx_ptype_5numpy_number) __PYX_ERR(3, 827, __pyx_L1_error) - __pyx_mstate->__pyx_ptype_5numpy_integer = __Pyx_ImportType_3_1_1(__pyx_t_1, "numpy", "integer", + __Pyx_ImportType_CheckSize_Warn_3_2_8); if (!__pyx_mstate->__pyx_ptype_5numpy_number) __PYX_ERR(3, 849, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_integer = __Pyx_ImportType_3_2_8(__pyx_t_1, "numpy", "integer", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #elif CYTHON_COMPILING_IN_LIMITED_API - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #else - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #endif - __Pyx_ImportType_CheckSize_Warn_3_1_1); if (!__pyx_mstate->__pyx_ptype_5numpy_integer) __PYX_ERR(3, 829, __pyx_L1_error) - __pyx_mstate->__pyx_ptype_5numpy_signedinteger = __Pyx_ImportType_3_1_1(__pyx_t_1, "numpy", "signedinteger", + __Pyx_ImportType_CheckSize_Warn_3_2_8); if (!__pyx_mstate->__pyx_ptype_5numpy_integer) __PYX_ERR(3, 851, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_signedinteger = __Pyx_ImportType_3_2_8(__pyx_t_1, "numpy", "signedinteger", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #elif CYTHON_COMPILING_IN_LIMITED_API - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #else - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #endif - __Pyx_ImportType_CheckSize_Warn_3_1_1); if (!__pyx_mstate->__pyx_ptype_5numpy_signedinteger) __PYX_ERR(3, 831, __pyx_L1_error) - __pyx_mstate->__pyx_ptype_5numpy_unsignedinteger = __Pyx_ImportType_3_1_1(__pyx_t_1, "numpy", "unsignedinteger", + __Pyx_ImportType_CheckSize_Warn_3_2_8); if (!__pyx_mstate->__pyx_ptype_5numpy_signedinteger) __PYX_ERR(3, 853, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_unsignedinteger = __Pyx_ImportType_3_2_8(__pyx_t_1, "numpy", "unsignedinteger", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #elif CYTHON_COMPILING_IN_LIMITED_API - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #else - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #endif - __Pyx_ImportType_CheckSize_Warn_3_1_1); if (!__pyx_mstate->__pyx_ptype_5numpy_unsignedinteger) __PYX_ERR(3, 833, __pyx_L1_error) - __pyx_mstate->__pyx_ptype_5numpy_inexact = __Pyx_ImportType_3_1_1(__pyx_t_1, "numpy", "inexact", + __Pyx_ImportType_CheckSize_Warn_3_2_8); if (!__pyx_mstate->__pyx_ptype_5numpy_unsignedinteger) __PYX_ERR(3, 855, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_inexact = __Pyx_ImportType_3_2_8(__pyx_t_1, "numpy", "inexact", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #elif CYTHON_COMPILING_IN_LIMITED_API - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #else - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #endif - __Pyx_ImportType_CheckSize_Warn_3_1_1); if (!__pyx_mstate->__pyx_ptype_5numpy_inexact) __PYX_ERR(3, 835, __pyx_L1_error) - __pyx_mstate->__pyx_ptype_5numpy_floating = __Pyx_ImportType_3_1_1(__pyx_t_1, "numpy", "floating", + __Pyx_ImportType_CheckSize_Warn_3_2_8); if (!__pyx_mstate->__pyx_ptype_5numpy_inexact) __PYX_ERR(3, 857, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_floating = __Pyx_ImportType_3_2_8(__pyx_t_1, "numpy", "floating", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #elif CYTHON_COMPILING_IN_LIMITED_API - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #else - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #endif - __Pyx_ImportType_CheckSize_Warn_3_1_1); if (!__pyx_mstate->__pyx_ptype_5numpy_floating) __PYX_ERR(3, 837, __pyx_L1_error) - __pyx_mstate->__pyx_ptype_5numpy_complexfloating = __Pyx_ImportType_3_1_1(__pyx_t_1, "numpy", "complexfloating", + __Pyx_ImportType_CheckSize_Warn_3_2_8); if (!__pyx_mstate->__pyx_ptype_5numpy_floating) __PYX_ERR(3, 859, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_complexfloating = __Pyx_ImportType_3_2_8(__pyx_t_1, "numpy", "complexfloating", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #elif CYTHON_COMPILING_IN_LIMITED_API - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #else - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #endif - __Pyx_ImportType_CheckSize_Warn_3_1_1); if (!__pyx_mstate->__pyx_ptype_5numpy_complexfloating) __PYX_ERR(3, 839, __pyx_L1_error) - __pyx_mstate->__pyx_ptype_5numpy_flexible = __Pyx_ImportType_3_1_1(__pyx_t_1, "numpy", "flexible", + __Pyx_ImportType_CheckSize_Warn_3_2_8); if (!__pyx_mstate->__pyx_ptype_5numpy_complexfloating) __PYX_ERR(3, 861, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_flexible = __Pyx_ImportType_3_2_8(__pyx_t_1, "numpy", "flexible", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #elif CYTHON_COMPILING_IN_LIMITED_API - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #else - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #endif - __Pyx_ImportType_CheckSize_Warn_3_1_1); if (!__pyx_mstate->__pyx_ptype_5numpy_flexible) __PYX_ERR(3, 841, __pyx_L1_error) - __pyx_mstate->__pyx_ptype_5numpy_character = __Pyx_ImportType_3_1_1(__pyx_t_1, "numpy", "character", + __Pyx_ImportType_CheckSize_Warn_3_2_8); if (!__pyx_mstate->__pyx_ptype_5numpy_flexible) __PYX_ERR(3, 863, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_character = __Pyx_ImportType_3_2_8(__pyx_t_1, "numpy", "character", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #elif CYTHON_COMPILING_IN_LIMITED_API - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #else - sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyObject), + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyObject), #endif - __Pyx_ImportType_CheckSize_Warn_3_1_1); if (!__pyx_mstate->__pyx_ptype_5numpy_character) __PYX_ERR(3, 843, __pyx_L1_error) - __pyx_mstate->__pyx_ptype_5numpy_ufunc = __Pyx_ImportType_3_1_1(__pyx_t_1, "numpy", "ufunc", + __Pyx_ImportType_CheckSize_Warn_3_2_8); if (!__pyx_mstate->__pyx_ptype_5numpy_character) __PYX_ERR(3, 865, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_ufunc = __Pyx_ImportType_3_2_8(__pyx_t_1, "numpy", "ufunc", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyUFuncObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyUFuncObject), + sizeof(PyUFuncObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyUFuncObject), #elif CYTHON_COMPILING_IN_LIMITED_API - sizeof(PyUFuncObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyUFuncObject), + sizeof(PyUFuncObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyUFuncObject), #else - sizeof(PyUFuncObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_1(PyUFuncObject), + sizeof(PyUFuncObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_8(PyUFuncObject), #endif - __Pyx_ImportType_CheckSize_Ignore_3_1_1); if (!__pyx_mstate->__pyx_ptype_5numpy_ufunc) __PYX_ERR(3, 907, __pyx_L1_error) + __Pyx_ImportType_CheckSize_Ignore_3_2_8); if (!__pyx_mstate->__pyx_ptype_5numpy_ufunc) __PYX_ERR(3, 946, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; @@ -81912,7 +81021,7 @@ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec__ta_lib}, #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING - {Py_mod_gil, Py_MOD_GIL_USED}, + {Py_mod_gil, __Pyx_FREETHREADING_COMPATIBLE}, #endif #if PY_VERSION_HEX >= 0x030C0000 && CYTHON_USE_MODULE_STATE {Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED}, @@ -81974,7 +81083,8 @@ __Pyx_PyMODINIT_FUNC PyInit__ta_lib(void) return PyModuleDef_Init(&__pyx_moduledef); } /* ModuleCreationPEP489 */ -#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000 +#if CYTHON_COMPILING_IN_LIMITED_API && (__PYX_LIMITED_VERSION_HEX < 0x03090000\ + || ((defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS)) && __PYX_LIMITED_VERSION_HEX < 0x030A0000)) static PY_INT64_T __Pyx_GetCurrentInterpreterId(void) { { PyObject *module = PyImport_ImportModule("_interpreters"); // 3.13+ I think @@ -82004,12 +81114,15 @@ static PY_INT64_T __Pyx_GetCurrentInterpreterId(void) { #if !CYTHON_USE_MODULE_STATE static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { static PY_INT64_T main_interpreter_id = -1; -#if CYTHON_COMPILING_IN_GRAAL +#if CYTHON_COMPILING_IN_GRAAL && defined(GRAALPY_VERSION_NUM) && GRAALPY_VERSION_NUM > 0x19000000 + PY_INT64_T current_id = GraalPyInterpreterState_GetIDFromThreadState(PyThreadState_Get()); +#elif CYTHON_COMPILING_IN_GRAAL PY_INT64_T current_id = PyInterpreterState_GetIDFromThreadState(PyThreadState_Get()); -#elif CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX >= 0x03090000 - PY_INT64_T current_id = PyInterpreterState_GetID(PyInterpreterState_Get()); -#elif CYTHON_COMPILING_IN_LIMITED_API +#elif CYTHON_COMPILING_IN_LIMITED_API && (__PYX_LIMITED_VERSION_HEX < 0x03090000\ + || ((defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS)) && __PYX_LIMITED_VERSION_HEX < 0x030A0000)) PY_INT64_T current_id = __Pyx_GetCurrentInterpreterId(); +#elif CYTHON_COMPILING_IN_LIMITED_API + PY_INT64_T current_id = PyInterpreterState_GetID(PyInterpreterState_Get()); #else PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); #endif @@ -82085,8 +81198,8 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec__ta_lib(PyObject *__pyx_pyinit_mod PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - size_t __pyx_t_8; + size_t __pyx_t_7; + PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; @@ -82104,8 +81217,8 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec__ta_lib(PyObject *__pyx_pyinit_mod int __pyx_t_23; PyObject *__pyx_t_24 = NULL; PyObject *__pyx_t_25 = NULL; - int __pyx_t_26; - PyObject *__pyx_t_27 = NULL; + PyObject *__pyx_t_26 = NULL; + int __pyx_t_27; PyObject *__pyx_t_28 = NULL; PyObject *__pyx_t_29 = NULL; int __pyx_t_30; @@ -82154,45 +81267,28 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec__ta_lib(PyObject *__pyx_pyinit_mod if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_mstate->__pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) /* ImportRefnannyAPI */ #if CYTHON_REFNANNY -__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); -if (!__Pyx_RefNanny) { - PyErr_Clear(); - __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); - if (!__Pyx_RefNanny) - Py_FatalError("failed to import 'refnanny' module"); -} -#endif - -__Pyx_RefNannySetupContext("PyInit__ta_lib", 0); - if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pxy_PyFrame_Initialize_Offsets - __Pxy_PyFrame_Initialize_Offsets(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); + if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); + } #endif + +__Pyx_RefNannySetupContext("PyInit__ta_lib", 0); + __Pyx_init_runtime_version(); + if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_mstate->__pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_mstate->__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_mstate->__pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_mstate->__pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pyx_CyFunction_USED - if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_FusedFunction_USED - if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Coroutine_USED - if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Generator_USED - if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_AsyncGen_USED - if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif /*--- Library function declarations ---*/ /*--- Initialize various global constants etc. ---*/ - if (__Pyx_InitConstants(__pyx_mstate) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_InitConstants(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) stringtab_initialized = 1; - if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_InitGlobals() < (0)) __PYX_ERR(0, 1, __pyx_L1_error) if (__pyx_module_is_main_talib___ta_lib) { - if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_name_2, __pyx_mstate_global->__pyx_n_u_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_name_2, __pyx_mstate_global->__pyx_n_u_main) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) } { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) @@ -82201,10 +81297,10 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); } } /*--- Builtin init code ---*/ - if (__Pyx_InitCachedBuiltins(__pyx_mstate) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_InitCachedBuiltins(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Constants init code ---*/ - if (__Pyx_InitCachedConstants(__pyx_mstate) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - if (__Pyx_CreateCodeObjects(__pyx_mstate) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_InitCachedConstants(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_CreateCodeObjects(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Global type/function init code ---*/ (void)__Pyx_modinit_global_init_code(__pyx_mstate); (void)__Pyx_modinit_variable_export_code(__pyx_mstate); @@ -82217,22 +81313,31 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); __pyx_t_2 = __Pyx_PyBytes_FromString(TA_GetVersionString()); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_version, __pyx_t_2) < 0) __PYX_ERR(1, 4, __pyx_L1_error) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_version, __pyx_t_2) < (0)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_1_ta_check_success, 0, __pyx_mstate_global->__pyx_n_u_ta_check_success, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_check_success, __pyx_t_2) < 0) __PYX_ERR(1, 6, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_check_success, __pyx_t_2) < (0)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_3_ta_initialize, 0, __pyx_mstate_global->__pyx_n_u_ta_initialize, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 50, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_initialize, __pyx_t_2) < 0) __PYX_ERR(1, 50, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_initialize, __pyx_t_2) < (0)) __PYX_ERR(1, 50, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_5_ta_shutdown, 0, __pyx_mstate_global->__pyx_n_u_ta_shutdown, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[2])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 55, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_shutdown, __pyx_t_2) < 0) __PYX_ERR(1, 55, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_shutdown, __pyx_t_2) < (0)) __PYX_ERR(1, 55, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PEP560_update_bases(__pyx_mstate_global->__pyx_tuple[2]); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 60, __pyx_L1_error) @@ -82246,89 +81351,17 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); } __pyx_t_6 = NULL; - __Pyx_INCREF(__pyx_builtin_range); - __pyx_t_7 = __pyx_builtin_range; - __pyx_t_8 = 1; + __pyx_t_7 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_mstate_global->__pyx_int_9}; - __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)(&PyRange_Type), __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); } - if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) { - PyObject* sequence = __pyx_t_5; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 9)) { - if (size > 9) __Pyx_RaiseTooManyValuesError(9); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 61, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_7 = PyTuple_GET_ITEM(sequence, 0); - __Pyx_INCREF(__pyx_t_7); - __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); - __Pyx_INCREF(__pyx_t_6); - __pyx_t_9 = PyTuple_GET_ITEM(sequence, 2); - __Pyx_INCREF(__pyx_t_9); - __pyx_t_10 = PyTuple_GET_ITEM(sequence, 3); - __Pyx_INCREF(__pyx_t_10); - __pyx_t_11 = PyTuple_GET_ITEM(sequence, 4); - __Pyx_INCREF(__pyx_t_11); - __pyx_t_12 = PyTuple_GET_ITEM(sequence, 5); - __Pyx_INCREF(__pyx_t_12); - __pyx_t_13 = PyTuple_GET_ITEM(sequence, 6); - __Pyx_INCREF(__pyx_t_13); - __pyx_t_14 = PyTuple_GET_ITEM(sequence, 7); - __Pyx_INCREF(__pyx_t_14); - __pyx_t_15 = PyTuple_GET_ITEM(sequence, 8); - __Pyx_INCREF(__pyx_t_15); - } else { - __pyx_t_7 = __Pyx_PyList_GetItemRef(sequence, 0); - if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 61, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_7); - __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 1); - if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 61, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_6); - __pyx_t_9 = __Pyx_PyList_GetItemRef(sequence, 2); - if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 61, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_9); - __pyx_t_10 = __Pyx_PyList_GetItemRef(sequence, 3); - if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 61, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_10); - __pyx_t_11 = __Pyx_PyList_GetItemRef(sequence, 4); - if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 61, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_11); - __pyx_t_12 = __Pyx_PyList_GetItemRef(sequence, 5); - if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 61, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_12); - __pyx_t_13 = __Pyx_PyList_GetItemRef(sequence, 6); - if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 61, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_13); - __pyx_t_14 = __Pyx_PyList_GetItemRef(sequence, 7); - if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 61, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_14); - __pyx_t_15 = __Pyx_PyList_GetItemRef(sequence, 8); - if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 61, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_15); - } - #else - { - Py_ssize_t i; - PyObject** temps[9] = {&__pyx_t_7,&__pyx_t_6,&__pyx_t_9,&__pyx_t_10,&__pyx_t_11,&__pyx_t_12,&__pyx_t_13,&__pyx_t_14,&__pyx_t_15}; - for (i=0; i < 9; i++) { - PyObject* item = __Pyx_PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(1, 61, __pyx_L1_error) - __Pyx_GOTREF(item); - *(temps[i]) = item; - } - } - #endif - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } else { + { Py_ssize_t index = -1; - PyObject** temps[9] = {&__pyx_t_7,&__pyx_t_6,&__pyx_t_9,&__pyx_t_10,&__pyx_t_11,&__pyx_t_12,&__pyx_t_13,&__pyx_t_14,&__pyx_t_15}; + PyObject** temps[9] = {&__pyx_t_6,&__pyx_t_8,&__pyx_t_9,&__pyx_t_10,&__pyx_t_11,&__pyx_t_12,&__pyx_t_13,&__pyx_t_14,&__pyx_t_15}; __pyx_t_16 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; @@ -82338,7 +81371,7 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); __Pyx_GOTREF(item); *(temps[index]) = item; } - if (__Pyx_IternextUnpackEndCheck(__pyx_t_17(__pyx_t_16), 9) < 0) __PYX_ERR(1, 61, __pyx_L1_error) + if (__Pyx_IternextUnpackEndCheck(__pyx_t_17(__pyx_t_16), 9) < (0)) __PYX_ERR(1, 61, __pyx_L1_error) __pyx_t_17 = NULL; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; goto __pyx_L3_unpacking_done; @@ -82349,38 +81382,47 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); __PYX_ERR(1, 61, __pyx_L1_error) __pyx_L3_unpacking_done:; } - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SMA, __pyx_t_7) < 0) __PYX_ERR(1, 61, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_EMA, __pyx_t_6) < 0) __PYX_ERR(1, 61, __pyx_L1_error) + if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SMA, __pyx_t_6) < (0)) __PYX_ERR(1, 61, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_WMA, __pyx_t_9) < 0) __PYX_ERR(1, 61, __pyx_L1_error) + if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_EMA, __pyx_t_8) < (0)) __PYX_ERR(1, 61, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_WMA, __pyx_t_9) < (0)) __PYX_ERR(1, 61, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DEMA, __pyx_t_10) < 0) __PYX_ERR(1, 61, __pyx_L1_error) + if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DEMA, __pyx_t_10) < (0)) __PYX_ERR(1, 61, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_TEMA, __pyx_t_11) < 0) __PYX_ERR(1, 61, __pyx_L1_error) + if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_TEMA, __pyx_t_11) < (0)) __PYX_ERR(1, 61, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_TRIMA, __pyx_t_12) < 0) __PYX_ERR(1, 61, __pyx_L1_error) + if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_TRIMA, __pyx_t_12) < (0)) __PYX_ERR(1, 61, __pyx_L1_error) __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_KAMA, __pyx_t_13) < 0) __PYX_ERR(1, 61, __pyx_L1_error) + if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_KAMA, __pyx_t_13) < (0)) __PYX_ERR(1, 61, __pyx_L1_error) __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_MAMA, __pyx_t_14) < 0) __PYX_ERR(1, 61, __pyx_L1_error) + if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_MAMA, __pyx_t_14) < (0)) __PYX_ERR(1, 61, __pyx_L1_error) __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_T3, __pyx_t_15) < 0) __PYX_ERR(1, 61, __pyx_L1_error) + if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_T3, __pyx_t_15) < (0)) __PYX_ERR(1, 61, __pyx_L1_error) __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_7MA_Type_1__init__, 0, __pyx_mstate_global->__pyx_n_u_MA_Type___init, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[3])); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_init, __pyx_t_5) < 0) __PYX_ERR(1, 63, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_init, __pyx_t_5) < (0)) __PYX_ERR(1, 63, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_7MA_Type_3__getitem__, 0, __pyx_mstate_global->__pyx_n_u_MA_Type___getitem, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[4])); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 76, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_getitem, __pyx_t_5) < 0) __PYX_ERR(1, 76, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_getitem, __pyx_t_5) < (0)) __PYX_ERR(1, 76, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MA_Type, __pyx_t_2, __pyx_t_4, NULL, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 60, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MA_Type, __pyx_t_5) < 0) __PYX_ERR(1, 60, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MA_Type, __pyx_t_5) < (0)) __PYX_ERR(1, 60, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -82389,22 +81431,22 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); __pyx_t_3 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 79, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = 1; + __pyx_t_7 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 79, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MA_Type, __pyx_t_2) < 0) __PYX_ERR(1, 79, __pyx_L1_error) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MA_Type, __pyx_t_2) < (0)) __PYX_ERR(1, 79, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 81, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_NONE, __pyx_mstate_global->__pyx_int_neg_1) < 0) __PYX_ERR(1, 81, __pyx_L1_error) - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_func_unst_ids, __pyx_t_2) < 0) __PYX_ERR(1, 81, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_NONE, __pyx_mstate_global->__pyx_int_neg_1) < (0)) __PYX_ERR(1, 81, __pyx_L1_error) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_func_unst_ids, __pyx_t_2) < (0)) __PYX_ERR(1, 81, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); @@ -82416,13 +81458,13 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; for (;;) { if (__pyx_t_18 >= 24) break; - __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_18); + __pyx_t_4 = __Pyx_PyList_GetItemRefFast(__pyx_t_3, __pyx_t_18, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_18; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 82, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_name, __pyx_t_4) < 0) __PYX_ERR(1, 82, __pyx_L1_error) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_name, __pyx_t_4) < (0)) __PYX_ERR(1, 82, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_i, __pyx_t_2) < 0) __PYX_ERR(1, 82, __pyx_L1_error) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_i, __pyx_t_2) < (0)) __PYX_ERR(1, 82, __pyx_L1_error) __pyx_t_4 = __Pyx_PyLong_AddObjC(__pyx_t_2, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 82, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); @@ -82446,22 +81488,34 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_7_ta_set_unstable_period, 0, __pyx_mstate_global->__pyx_n_u_ta_set_unstable_period, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[5])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 90, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_set_unstable_period, __pyx_t_2) < 0) __PYX_ERR(1, 90, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_set_unstable_period, __pyx_t_2) < (0)) __PYX_ERR(1, 90, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_9_ta_get_unstable_period, 0, __pyx_mstate_global->__pyx_n_u_ta_get_unstable_period, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[6])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 96, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_get_unstable_period, __pyx_t_2) < 0) __PYX_ERR(1, 96, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_get_unstable_period, __pyx_t_2) < (0)) __PYX_ERR(1, 96, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_11_ta_set_compatibility, 0, __pyx_mstate_global->__pyx_n_u_ta_set_compatibility, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[7])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 102, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_set_compatibility, __pyx_t_2) < 0) __PYX_ERR(1, 102, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_set_compatibility, __pyx_t_2) < (0)) __PYX_ERR(1, 102, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_13_ta_get_compatibility, 0, __pyx_mstate_global->__pyx_n_u_ta_get_compatibility, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[8])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 107, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_get_compatibility, __pyx_t_2) < 0) __PYX_ERR(1, 107, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_get_compatibility, __pyx_t_2) < (0)) __PYX_ERR(1, 107, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PEP560_update_bases(__pyx_mstate_global->__pyx_tuple[4]); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 112, __pyx_L1_error) @@ -82475,104 +81529,17 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); } __pyx_t_5 = NULL; - __Pyx_INCREF(__pyx_builtin_range); - __pyx_t_14 = __pyx_builtin_range; - __pyx_t_8 = 1; + __pyx_t_7 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_int_12}; - __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_14, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_15 = __Pyx_PyObject_FastCall((PyObject*)(&PyRange_Type), __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 115, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); } - if ((likely(PyTuple_CheckExact(__pyx_t_15))) || (PyList_CheckExact(__pyx_t_15))) { - PyObject* sequence = __pyx_t_15; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 12)) { - if (size > 12) __Pyx_RaiseTooManyValuesError(12); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 113, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_14 = PyTuple_GET_ITEM(sequence, 0); - __Pyx_INCREF(__pyx_t_14); - __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); - __Pyx_INCREF(__pyx_t_5); - __pyx_t_13 = PyTuple_GET_ITEM(sequence, 2); - __Pyx_INCREF(__pyx_t_13); - __pyx_t_12 = PyTuple_GET_ITEM(sequence, 3); - __Pyx_INCREF(__pyx_t_12); - __pyx_t_11 = PyTuple_GET_ITEM(sequence, 4); - __Pyx_INCREF(__pyx_t_11); - __pyx_t_10 = PyTuple_GET_ITEM(sequence, 5); - __Pyx_INCREF(__pyx_t_10); - __pyx_t_9 = PyTuple_GET_ITEM(sequence, 6); - __Pyx_INCREF(__pyx_t_9); - __pyx_t_6 = PyTuple_GET_ITEM(sequence, 7); - __Pyx_INCREF(__pyx_t_6); - __pyx_t_7 = PyTuple_GET_ITEM(sequence, 8); - __Pyx_INCREF(__pyx_t_7); - __pyx_t_16 = PyTuple_GET_ITEM(sequence, 9); - __Pyx_INCREF(__pyx_t_16); - __pyx_t_19 = PyTuple_GET_ITEM(sequence, 10); - __Pyx_INCREF(__pyx_t_19); - __pyx_t_20 = PyTuple_GET_ITEM(sequence, 11); - __Pyx_INCREF(__pyx_t_20); - } else { - __pyx_t_14 = __Pyx_PyList_GetItemRef(sequence, 0); - if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 113, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_14); - __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 1); - if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 113, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_5); - __pyx_t_13 = __Pyx_PyList_GetItemRef(sequence, 2); - if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 113, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_13); - __pyx_t_12 = __Pyx_PyList_GetItemRef(sequence, 3); - if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 113, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_12); - __pyx_t_11 = __Pyx_PyList_GetItemRef(sequence, 4); - if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 113, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_11); - __pyx_t_10 = __Pyx_PyList_GetItemRef(sequence, 5); - if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 113, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_10); - __pyx_t_9 = __Pyx_PyList_GetItemRef(sequence, 6); - if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 113, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_9); - __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 7); - if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 113, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyList_GetItemRef(sequence, 8); - if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 113, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_7); - __pyx_t_16 = __Pyx_PyList_GetItemRef(sequence, 9); - if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 113, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_16); - __pyx_t_19 = __Pyx_PyList_GetItemRef(sequence, 10); - if (unlikely(!__pyx_t_19)) __PYX_ERR(1, 113, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_19); - __pyx_t_20 = __Pyx_PyList_GetItemRef(sequence, 11); - if (unlikely(!__pyx_t_20)) __PYX_ERR(1, 113, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_20); - } - #else - { - Py_ssize_t i; - PyObject** temps[12] = {&__pyx_t_14,&__pyx_t_5,&__pyx_t_13,&__pyx_t_12,&__pyx_t_11,&__pyx_t_10,&__pyx_t_9,&__pyx_t_6,&__pyx_t_7,&__pyx_t_16,&__pyx_t_19,&__pyx_t_20}; - for (i=0; i < 12; i++) { - PyObject* item = __Pyx_PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(1, 113, __pyx_L1_error) - __Pyx_GOTREF(item); - *(temps[i]) = item; - } - } - #endif - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - } else { + { Py_ssize_t index = -1; - PyObject** temps[12] = {&__pyx_t_14,&__pyx_t_5,&__pyx_t_13,&__pyx_t_12,&__pyx_t_11,&__pyx_t_10,&__pyx_t_9,&__pyx_t_6,&__pyx_t_7,&__pyx_t_16,&__pyx_t_19,&__pyx_t_20}; + PyObject** temps[12] = {&__pyx_t_5,&__pyx_t_14,&__pyx_t_13,&__pyx_t_12,&__pyx_t_11,&__pyx_t_10,&__pyx_t_9,&__pyx_t_8,&__pyx_t_6,&__pyx_t_16,&__pyx_t_19,&__pyx_t_20}; __pyx_t_21 = PyObject_GetIter(__pyx_t_15); if (unlikely(!__pyx_t_21)) __PYX_ERR(1, 113, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_21); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; @@ -82582,7 +81549,7 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); __Pyx_GOTREF(item); *(temps[index]) = item; } - if (__Pyx_IternextUnpackEndCheck(__pyx_t_17(__pyx_t_21), 12) < 0) __PYX_ERR(1, 113, __pyx_L1_error) + if (__Pyx_IternextUnpackEndCheck(__pyx_t_17(__pyx_t_21), 12) < (0)) __PYX_ERR(1, 113, __pyx_L1_error) __pyx_t_17 = NULL; __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; goto __pyx_L8_unpacking_done; @@ -82594,34 +81561,37 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); __pyx_L8_unpacking_done:; } - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_BodyLong, __pyx_t_14) < 0) __PYX_ERR(1, 113, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_BodyVeryLong, __pyx_t_5) < 0) __PYX_ERR(1, 113, __pyx_L1_error) + if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_BodyLong, __pyx_t_5) < (0)) __PYX_ERR(1, 113, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_BodyShort, __pyx_t_13) < 0) __PYX_ERR(1, 113, __pyx_L1_error) + if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_BodyVeryLong, __pyx_t_14) < (0)) __PYX_ERR(1, 113, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_BodyShort, __pyx_t_13) < (0)) __PYX_ERR(1, 113, __pyx_L1_error) __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_BodyDoji, __pyx_t_12) < 0) __PYX_ERR(1, 113, __pyx_L1_error) + if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_BodyDoji, __pyx_t_12) < (0)) __PYX_ERR(1, 113, __pyx_L1_error) __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ShadowLong, __pyx_t_11) < 0) __PYX_ERR(1, 113, __pyx_L1_error) + if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ShadowLong, __pyx_t_11) < (0)) __PYX_ERR(1, 113, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ShadowVeryLong, __pyx_t_10) < 0) __PYX_ERR(1, 113, __pyx_L1_error) + if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ShadowVeryLong, __pyx_t_10) < (0)) __PYX_ERR(1, 113, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ShadowShort, __pyx_t_9) < 0) __PYX_ERR(1, 114, __pyx_L1_error) + if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ShadowShort, __pyx_t_9) < (0)) __PYX_ERR(1, 114, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ShadowVeryShort, __pyx_t_6) < 0) __PYX_ERR(1, 114, __pyx_L1_error) + if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ShadowVeryShort, __pyx_t_8) < (0)) __PYX_ERR(1, 114, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Near, __pyx_t_6) < (0)) __PYX_ERR(1, 114, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Near, __pyx_t_7) < 0) __PYX_ERR(1, 114, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Far, __pyx_t_16) < 0) __PYX_ERR(1, 114, __pyx_L1_error) + if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Far, __pyx_t_16) < (0)) __PYX_ERR(1, 114, __pyx_L1_error) __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Equal, __pyx_t_19) < 0) __PYX_ERR(1, 114, __pyx_L1_error) + if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Equal, __pyx_t_19) < (0)) __PYX_ERR(1, 114, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_AllCandleSettings, __pyx_t_20) < 0) __PYX_ERR(1, 114, __pyx_L1_error) + if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_AllCandleSettings, __pyx_t_20) < (0)) __PYX_ERR(1, 114, __pyx_L1_error) __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; __pyx_t_15 = __Pyx_Py3ClassCreate(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_CandleSettingType, __pyx_t_2, __pyx_t_4, NULL, 0, 1); if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 112, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CandleSettingType, __pyx_t_15) < 0) __PYX_ERR(1, 112, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_15); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CandleSettingType, __pyx_t_15) < (0)) __PYX_ERR(1, 112, __pyx_L1_error) __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -82630,16 +81600,16 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); __pyx_t_3 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_CandleSettingType); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 117, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = 1; + __pyx_t_7 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 117, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CandleSettingType, __pyx_t_2) < 0) __PYX_ERR(1, 117, __pyx_L1_error) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CandleSettingType, __pyx_t_2) < (0)) __PYX_ERR(1, 117, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PEP560_update_bases(__pyx_mstate_global->__pyx_tuple[6]); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 119, __pyx_L1_error) @@ -82653,86 +81623,50 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); } __pyx_t_20 = NULL; - __Pyx_INCREF(__pyx_builtin_range); - __pyx_t_19 = __pyx_builtin_range; - __pyx_t_8 = 1; + __pyx_t_7 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_20, __pyx_mstate_global->__pyx_int_3}; - __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_19, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_15 = __Pyx_PyObject_FastCall((PyObject*)(&PyRange_Type), __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0; - __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); } - if ((likely(PyTuple_CheckExact(__pyx_t_15))) || (PyList_CheckExact(__pyx_t_15))) { - PyObject* sequence = __pyx_t_15; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 3)) { - if (size > 3) __Pyx_RaiseTooManyValuesError(3); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 120, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_19 = PyTuple_GET_ITEM(sequence, 0); - __Pyx_INCREF(__pyx_t_19); - __pyx_t_20 = PyTuple_GET_ITEM(sequence, 1); - __Pyx_INCREF(__pyx_t_20); - __pyx_t_16 = PyTuple_GET_ITEM(sequence, 2); - __Pyx_INCREF(__pyx_t_16); - } else { - __pyx_t_19 = __Pyx_PyList_GetItemRef(sequence, 0); - if (unlikely(!__pyx_t_19)) __PYX_ERR(1, 120, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_19); - __pyx_t_20 = __Pyx_PyList_GetItemRef(sequence, 1); - if (unlikely(!__pyx_t_20)) __PYX_ERR(1, 120, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_20); - __pyx_t_16 = __Pyx_PyList_GetItemRef(sequence, 2); - if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 120, __pyx_L1_error) - __Pyx_XGOTREF(__pyx_t_16); - } - #else - __pyx_t_19 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_19)) __PYX_ERR(1, 120, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_19); - __pyx_t_20 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_20)) __PYX_ERR(1, 120, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __pyx_t_16 = __Pyx_PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 120, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_16); - #endif - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - } else { + { Py_ssize_t index = -1; - __pyx_t_7 = PyObject_GetIter(__pyx_t_15); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 120, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = PyObject_GetIter(__pyx_t_15); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 120, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); - index = 0; __pyx_t_19 = __pyx_t_17(__pyx_t_7); if (unlikely(!__pyx_t_19)) goto __pyx_L9_unpacking_failed; - __Pyx_GOTREF(__pyx_t_19); - index = 1; __pyx_t_20 = __pyx_t_17(__pyx_t_7); if (unlikely(!__pyx_t_20)) goto __pyx_L9_unpacking_failed; + __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); + index = 0; __pyx_t_20 = __pyx_t_17(__pyx_t_6); if (unlikely(!__pyx_t_20)) goto __pyx_L9_unpacking_failed; __Pyx_GOTREF(__pyx_t_20); - index = 2; __pyx_t_16 = __pyx_t_17(__pyx_t_7); if (unlikely(!__pyx_t_16)) goto __pyx_L9_unpacking_failed; + index = 1; __pyx_t_19 = __pyx_t_17(__pyx_t_6); if (unlikely(!__pyx_t_19)) goto __pyx_L9_unpacking_failed; + __Pyx_GOTREF(__pyx_t_19); + index = 2; __pyx_t_16 = __pyx_t_17(__pyx_t_6); if (unlikely(!__pyx_t_16)) goto __pyx_L9_unpacking_failed; __Pyx_GOTREF(__pyx_t_16); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_17(__pyx_t_7), 3) < 0) __PYX_ERR(1, 120, __pyx_L1_error) + if (__Pyx_IternextUnpackEndCheck(__pyx_t_17(__pyx_t_6), 3) < (0)) __PYX_ERR(1, 120, __pyx_L1_error) __pyx_t_17 = NULL; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L10_unpacking_done; __pyx_L9_unpacking_failed:; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_17 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(1, 120, __pyx_L1_error) __pyx_L10_unpacking_done:; } - if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_RealBody, __pyx_t_19) < 0) __PYX_ERR(1, 120, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_HighLow, __pyx_t_20) < 0) __PYX_ERR(1, 120, __pyx_L1_error) + if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_RealBody, __pyx_t_20) < (0)) __PYX_ERR(1, 120, __pyx_L1_error) __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_Shadows, __pyx_t_16) < 0) __PYX_ERR(1, 120, __pyx_L1_error) + if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_HighLow, __pyx_t_19) < (0)) __PYX_ERR(1, 120, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_Shadows, __pyx_t_16) < (0)) __PYX_ERR(1, 120, __pyx_L1_error) __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_15 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_RangeType, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 119, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_RangeType, __pyx_t_15) < 0) __PYX_ERR(1, 119, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_15); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_RangeType, __pyx_t_15) < (0)) __PYX_ERR(1, 119, __pyx_L1_error) __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; @@ -82741,1581 +81675,2078 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); __pyx_t_4 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_RangeType); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 122, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = 1; + __pyx_t_7 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 122, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_RangeType, __pyx_t_2) < 0) __PYX_ERR(1, 122, __pyx_L1_error) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_RangeType, __pyx_t_2) < (0)) __PYX_ERR(1, 122, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_15_ta_set_candle_settings, 0, __pyx_mstate_global->__pyx_n_u_ta_set_candle_settings, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[9])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 124, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_set_candle_settings, __pyx_t_2) < 0) __PYX_ERR(1, 124, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_set_candle_settings, __pyx_t_2) < (0)) __PYX_ERR(1, 124, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_17_ta_restore_candle_default_settings, 0, __pyx_mstate_global->__pyx_n_u_ta_restore_candle_default_setti, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[10])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 129, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_restore_candle_default_setti, __pyx_t_2) < 0) __PYX_ERR(1, 129, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_restore_candle_default_setti, __pyx_t_2) < (0)) __PYX_ERR(1, 129, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_nan); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2, __pyx_L1_error) + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_nan}; + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_numpy, __pyx_imported_names, 1, __pyx_mstate_global->__pyx_kp_u_talib_numpy, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2, __pyx_L1_error) + } + __pyx_t_2 = __pyx_t_1; __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_numpy, __pyx_t_2, -1); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_nan}; + __pyx_t_18 = 0; { + __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_18]); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_18], __pyx_t_3) < (0)) __PYX_ERR(4, 2, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_nan); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2, __pyx_L1_error) + + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_nan); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_nan, __pyx_t_2) < 0) __PYX_ERR(4, 2, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_22 == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 7, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_nan); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_22 = __Pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_22 == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 7, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_5talib_7_ta_lib_NaN = __pyx_t_22; __pyx_t_23 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_23 == ((int)-1))) __PYX_ERR(4, 15, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 144, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - - __pyx_t_2 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 142, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 144, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_19ACCBANDS, 0, __pyx_mstate_global->__pyx_n_u_ACCBANDS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[11])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 142, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_2); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ACCBANDS, __pyx_t_3) < 0) __PYX_ERR(4, 142, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_21ACOS, 0, __pyx_mstate_global->__pyx_n_u_ACOS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[12])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 181, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ACOS, __pyx_t_3) < 0) __PYX_ERR(4, 181, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_23AD, 0, __pyx_mstate_global->__pyx_n_u_AD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[13])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 210, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_AD, __pyx_t_3) < 0) __PYX_ERR(4, 210, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_25ADD, 0, __pyx_mstate_global->__pyx_n_u_ADD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[14])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 242, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ADD, __pyx_t_3) < 0) __PYX_ERR(4, 242, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 275, __pyx_L1_error) + __pyx_t_3 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 142, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 275, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - - __pyx_t_4 = PyTuple_Pack(2, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 273, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_27ADOSC, 0, __pyx_mstate_global->__pyx_n_u_ADOSC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[15])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 273, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_19ACCBANDS, 0, __pyx_mstate_global->__pyx_n_u_ACCBANDS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[11])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 142, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_4); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ADOSC, __pyx_t_2) < 0) __PYX_ERR(4, 273, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ACCBANDS, __pyx_t_2) < (0)) __PYX_ERR(4, 142, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 310, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - - __pyx_t_4 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 308, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_29ADX, 0, __pyx_mstate_global->__pyx_n_u_ADX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[16])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 308, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_21ACOS, 0, __pyx_mstate_global->__pyx_n_u_ACOS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[12])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 181, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_4); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ADX, __pyx_t_2) < 0) __PYX_ERR(4, 308, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ACOS, __pyx_t_2) < (0)) __PYX_ERR(4, 181, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 343, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_23AD, 0, __pyx_mstate_global->__pyx_n_u_AD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[13])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 210, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - - __pyx_t_4 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 341, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_AD, __pyx_t_2) < (0)) __PYX_ERR(4, 210, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_31ADXR, 0, __pyx_mstate_global->__pyx_n_u_ADXR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[17])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 341, __pyx_L1_error) + + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_25ADD, 0, __pyx_mstate_global->__pyx_n_u_ADD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[14])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_4); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ADXR, __pyx_t_2) < 0) __PYX_ERR(4, 341, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ADD, __pyx_t_2) < (0)) __PYX_ERR(4, 242, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 376, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 376, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 376, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_15 = PyTuple_Pack(3, __pyx_t_2, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 374, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); + __pyx_t_4 = PyTuple_Pack(2, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_33APO, 0, __pyx_mstate_global->__pyx_n_u_APO, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[18])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 374, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_APO, __pyx_t_3) < 0) __PYX_ERR(4, 374, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 409, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - - __pyx_t_15 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 407, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_35AROON, 0, __pyx_mstate_global->__pyx_n_u_AROON, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[19])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 407, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_AROON, __pyx_t_3) < 0) __PYX_ERR(4, 407, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 444, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - - __pyx_t_15 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 442, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_37AROONOSC, 0, __pyx_mstate_global->__pyx_n_u_AROONOSC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[20])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 442, __pyx_L1_error) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_27ADOSC, 0, __pyx_mstate_global->__pyx_n_u_ADOSC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[15])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 273, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_AROONOSC, __pyx_t_3) < 0) __PYX_ERR(4, 442, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_39ASIN, 0, __pyx_mstate_global->__pyx_n_u_ASIN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[21])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 474, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ASIN, __pyx_t_3) < 0) __PYX_ERR(4, 474, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_41ATAN, 0, __pyx_mstate_global->__pyx_n_u_ATAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[22])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 503, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ATAN, __pyx_t_3) < 0) __PYX_ERR(4, 503, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ADOSC, __pyx_t_3) < (0)) __PYX_ERR(4, 273, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 534, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 310, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_15 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 532, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_43ATR, 0, __pyx_mstate_global->__pyx_n_u_ATR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[23])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 532, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ATR, __pyx_t_3) < 0) __PYX_ERR(4, 532, __pyx_L1_error) + __pyx_t_4 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 308, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_45AVGPRICE, 0, __pyx_mstate_global->__pyx_n_u_AVGPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[24])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 565, __pyx_L1_error) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_29ADX, 0, __pyx_mstate_global->__pyx_n_u_ADX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[16])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 308, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_AVGPRICE, __pyx_t_3) < 0) __PYX_ERR(4, 565, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ADX, __pyx_t_3) < (0)) __PYX_ERR(4, 308, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 599, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_15 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 597, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); + __pyx_t_4 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 341, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_47AVGDEV, 0, __pyx_mstate_global->__pyx_n_u_AVGDEV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[25])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 597, __pyx_L1_error) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_31ADXR, 0, __pyx_mstate_global->__pyx_n_u_ADXR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[17])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 341, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_AVGDEV, __pyx_t_3) < 0) __PYX_ERR(4, 597, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ADXR, __pyx_t_3) < (0)) __PYX_ERR(4, 341, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 630, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 376, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_15 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 630, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __pyx_t_4 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 630, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 376, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 630, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 376, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_16 = PyTuple_Pack(4, __pyx_t_3, __pyx_t_15, __pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 628, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_16); + __pyx_t_15 = PyTuple_Pack(3, __pyx_t_3, __pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 374, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_49BBANDS, 0, __pyx_mstate_global->__pyx_n_u_BBANDS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[26])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 628, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_33APO, 0, __pyx_mstate_global->__pyx_n_u_APO, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[18])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 374, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16); - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_BBANDS, __pyx_t_2) < 0) __PYX_ERR(4, 628, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 670, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 668, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_51BETA, 0, __pyx_mstate_global->__pyx_n_u_BETA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[27])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 668, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16); - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_BETA, __pyx_t_2) < 0) __PYX_ERR(4, 668, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_53BOP, 0, __pyx_mstate_global->__pyx_n_u_BOP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[28])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 701, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_BOP, __pyx_t_2) < 0) __PYX_ERR(4, 701, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_15); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_APO, __pyx_t_2) < (0)) __PYX_ERR(4, 374, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 735, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 733, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_55CCI, 0, __pyx_mstate_global->__pyx_n_u_CCI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[29])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 733, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 409, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16); - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CCI, __pyx_t_2) < 0) __PYX_ERR(4, 733, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_57CDL2CROWS, 0, __pyx_mstate_global->__pyx_n_u_CDL2CROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[30])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 766, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL2CROWS, __pyx_t_2) < 0) __PYX_ERR(4, 766, __pyx_L1_error) + __pyx_t_15 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_59CDL3BLACKCROWS, 0, __pyx_mstate_global->__pyx_n_u_CDL3BLACKCROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[31])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 798, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_35AROON, 0, __pyx_mstate_global->__pyx_n_u_AROON, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[19])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 407, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3BLACKCROWS, __pyx_t_2) < 0) __PYX_ERR(4, 798, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_15); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_AROON, __pyx_t_2) < (0)) __PYX_ERR(4, 407, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_61CDL3INSIDE, 0, __pyx_mstate_global->__pyx_n_u_CDL3INSIDE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[32])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 830, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 444, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3INSIDE, __pyx_t_2) < 0) __PYX_ERR(4, 830, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_63CDL3LINESTRIKE, 0, __pyx_mstate_global->__pyx_n_u_CDL3LINESTRIKE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[33])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 862, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3LINESTRIKE, __pyx_t_2) < 0) __PYX_ERR(4, 862, __pyx_L1_error) + __pyx_t_15 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_65CDL3OUTSIDE, 0, __pyx_mstate_global->__pyx_n_u_CDL3OUTSIDE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[34])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 894, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_37AROONOSC, 0, __pyx_mstate_global->__pyx_n_u_AROONOSC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[20])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 442, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3OUTSIDE, __pyx_t_2) < 0) __PYX_ERR(4, 894, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_15); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_AROONOSC, __pyx_t_2) < (0)) __PYX_ERR(4, 442, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_67CDL3STARSINSOUTH, 0, __pyx_mstate_global->__pyx_n_u_CDL3STARSINSOUTH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[35])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 926, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_39ASIN, 0, __pyx_mstate_global->__pyx_n_u_ASIN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[21])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3STARSINSOUTH, __pyx_t_2) < 0) __PYX_ERR(4, 926, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ASIN, __pyx_t_2) < (0)) __PYX_ERR(4, 474, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_69CDL3WHITESOLDIERS, 0, __pyx_mstate_global->__pyx_n_u_CDL3WHITESOLDIERS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[36])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 958, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_41ATAN, 0, __pyx_mstate_global->__pyx_n_u_ATAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[22])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 503, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3WHITESOLDIERS, __pyx_t_2) < 0) __PYX_ERR(4, 958, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ATAN, __pyx_t_2) < (0)) __PYX_ERR(4, 503, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 992, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 990, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_71CDLABANDONEDBABY, 0, __pyx_mstate_global->__pyx_n_u_CDLABANDONEDBABY, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[37])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 990, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 534, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16); - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLABANDONEDBABY, __pyx_t_2) < 0) __PYX_ERR(4, 990, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_73CDLADVANCEBLOCK, 0, __pyx_mstate_global->__pyx_n_u_CDLADVANCEBLOCK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[38])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1024, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLADVANCEBLOCK, __pyx_t_2) < 0) __PYX_ERR(4, 1024, __pyx_L1_error) + __pyx_t_15 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 532, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_75CDLBELTHOLD, 0, __pyx_mstate_global->__pyx_n_u_CDLBELTHOLD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[39])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1056, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_43ATR, 0, __pyx_mstate_global->__pyx_n_u_ATR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[23])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 532, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLBELTHOLD, __pyx_t_2) < 0) __PYX_ERR(4, 1056, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_15); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ATR, __pyx_t_2) < (0)) __PYX_ERR(4, 532, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_77CDLBREAKAWAY, 0, __pyx_mstate_global->__pyx_n_u_CDLBREAKAWAY, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[40])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1088, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_45AVGPRICE, 0, __pyx_mstate_global->__pyx_n_u_AVGPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[24])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 565, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLBREAKAWAY, __pyx_t_2) < 0) __PYX_ERR(4, 1088, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_AVGPRICE, __pyx_t_2) < (0)) __PYX_ERR(4, 565, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_79CDLCLOSINGMARUBOZU, 0, __pyx_mstate_global->__pyx_n_u_CDLCLOSINGMARUBOZU, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[41])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1120, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 599, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLCLOSINGMARUBOZU, __pyx_t_2) < 0) __PYX_ERR(4, 1120, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_81CDLCONCEALBABYSWALL, 0, __pyx_mstate_global->__pyx_n_u_CDLCONCEALBABYSWALL, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[42])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1152, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLCONCEALBABYSWALL, __pyx_t_2) < 0) __PYX_ERR(4, 1152, __pyx_L1_error) + __pyx_t_15 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 597, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_83CDLCOUNTERATTACK, 0, __pyx_mstate_global->__pyx_n_u_CDLCOUNTERATTACK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[43])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1184, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_47AVGDEV, 0, __pyx_mstate_global->__pyx_n_u_AVGDEV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[25])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 597, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLCOUNTERATTACK, __pyx_t_2) < 0) __PYX_ERR(4, 1184, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_15); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_AVGDEV, __pyx_t_2) < (0)) __PYX_ERR(4, 597, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyFloat_FromDouble(((double)0.5)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1218, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 630, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); + __pyx_t_15 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_4 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 1216, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(4, __pyx_t_2, __pyx_t_15, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 628, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_85CDLDARKCLOUDCOVER, 0, __pyx_mstate_global->__pyx_n_u_CDLDARKCLOUDCOVER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[44])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1216, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_49BBANDS, 0, __pyx_mstate_global->__pyx_n_u_BBANDS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[26])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 628, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLDARKCLOUDCOVER, __pyx_t_2) < 0) __PYX_ERR(4, 1216, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_87CDLDOJI, 0, __pyx_mstate_global->__pyx_n_u_CDLDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[45])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1250, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLDOJI, __pyx_t_2) < 0) __PYX_ERR(4, 1250, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_89CDLDOJISTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLDOJISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[46])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1282, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLDOJISTAR, __pyx_t_2) < 0) __PYX_ERR(4, 1282, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_91CDLDRAGONFLYDOJI, 0, __pyx_mstate_global->__pyx_n_u_CDLDRAGONFLYDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[47])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1314, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLDRAGONFLYDOJI, __pyx_t_2) < 0) __PYX_ERR(4, 1314, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_93CDLENGULFING, 0, __pyx_mstate_global->__pyx_n_u_CDLENGULFING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[48])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1346, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLENGULFING, __pyx_t_2) < 0) __PYX_ERR(4, 1346, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_BBANDS, __pyx_t_3) < (0)) __PYX_ERR(4, 628, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1380, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 670, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 1378, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 668, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_95CDLEVENINGDOJISTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLEVENINGDOJISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[49])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1378, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_51BETA, 0, __pyx_mstate_global->__pyx_n_u_BETA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[27])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 668, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLEVENINGDOJISTAR, __pyx_t_2) < 0) __PYX_ERR(4, 1378, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_BETA, __pyx_t_3) < (0)) __PYX_ERR(4, 668, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1414, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_53BOP, 0, __pyx_mstate_global->__pyx_n_u_BOP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[28])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 701, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_BOP, __pyx_t_3) < (0)) __PYX_ERR(4, 701, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 735, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 1412, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 733, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_97CDLEVENINGSTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLEVENINGSTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[50])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1412, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_55CCI, 0, __pyx_mstate_global->__pyx_n_u_CCI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[29])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 733, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLEVENINGSTAR, __pyx_t_2) < 0) __PYX_ERR(4, 1412, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_99CDLGAPSIDESIDEWHITE, 0, __pyx_mstate_global->__pyx_n_u_CDLGAPSIDESIDEWHITE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[51])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1446, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLGAPSIDESIDEWHITE, __pyx_t_2) < 0) __PYX_ERR(4, 1446, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CCI, __pyx_t_3) < (0)) __PYX_ERR(4, 733, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_101CDLGRAVESTONEDOJI, 0, __pyx_mstate_global->__pyx_n_u_CDLGRAVESTONEDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[52])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1478, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLGRAVESTONEDOJI, __pyx_t_2) < 0) __PYX_ERR(4, 1478, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_57CDL2CROWS, 0, __pyx_mstate_global->__pyx_n_u_CDL2CROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[30])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 766, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL2CROWS, __pyx_t_3) < (0)) __PYX_ERR(4, 766, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_103CDLHAMMER, 0, __pyx_mstate_global->__pyx_n_u_CDLHAMMER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[53])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1510, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHAMMER, __pyx_t_2) < 0) __PYX_ERR(4, 1510, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_59CDL3BLACKCROWS, 0, __pyx_mstate_global->__pyx_n_u_CDL3BLACKCROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[31])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 798, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3BLACKCROWS, __pyx_t_3) < (0)) __PYX_ERR(4, 798, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_105CDLHANGINGMAN, 0, __pyx_mstate_global->__pyx_n_u_CDLHANGINGMAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[54])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1542, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHANGINGMAN, __pyx_t_2) < 0) __PYX_ERR(4, 1542, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_61CDL3INSIDE, 0, __pyx_mstate_global->__pyx_n_u_CDL3INSIDE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[32])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 830, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3INSIDE, __pyx_t_3) < (0)) __PYX_ERR(4, 830, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_107CDLHARAMI, 0, __pyx_mstate_global->__pyx_n_u_CDLHARAMI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[55])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1574, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHARAMI, __pyx_t_2) < 0) __PYX_ERR(4, 1574, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_63CDL3LINESTRIKE, 0, __pyx_mstate_global->__pyx_n_u_CDL3LINESTRIKE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[33])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 862, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3LINESTRIKE, __pyx_t_3) < (0)) __PYX_ERR(4, 862, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_109CDLHARAMICROSS, 0, __pyx_mstate_global->__pyx_n_u_CDLHARAMICROSS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[56])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1606, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHARAMICROSS, __pyx_t_2) < 0) __PYX_ERR(4, 1606, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_65CDL3OUTSIDE, 0, __pyx_mstate_global->__pyx_n_u_CDL3OUTSIDE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[34])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 894, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3OUTSIDE, __pyx_t_3) < (0)) __PYX_ERR(4, 894, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_111CDLHIGHWAVE, 0, __pyx_mstate_global->__pyx_n_u_CDLHIGHWAVE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[57])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1638, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHIGHWAVE, __pyx_t_2) < 0) __PYX_ERR(4, 1638, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_67CDL3STARSINSOUTH, 0, __pyx_mstate_global->__pyx_n_u_CDL3STARSINSOUTH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[35])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 926, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3STARSINSOUTH, __pyx_t_3) < (0)) __PYX_ERR(4, 926, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_113CDLHIKKAKE, 0, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[58])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1670, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKE, __pyx_t_2) < 0) __PYX_ERR(4, 1670, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_69CDL3WHITESOLDIERS, 0, __pyx_mstate_global->__pyx_n_u_CDL3WHITESOLDIERS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[36])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 958, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3WHITESOLDIERS, __pyx_t_3) < (0)) __PYX_ERR(4, 958, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_115CDLHIKKAKEMOD, 0, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKEMOD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[59])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1702, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKEMOD, __pyx_t_2) < 0) __PYX_ERR(4, 1702, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 992, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_117CDLHOMINGPIGEON, 0, __pyx_mstate_global->__pyx_n_u_CDLHOMINGPIGEON, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[60])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1734, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHOMINGPIGEON, __pyx_t_2) < 0) __PYX_ERR(4, 1734, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 990, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_71CDLABANDONEDBABY, 0, __pyx_mstate_global->__pyx_n_u_CDLABANDONEDBABY, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[37])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 990, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLABANDONEDBABY, __pyx_t_3) < (0)) __PYX_ERR(4, 990, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_119CDLIDENTICAL3CROWS, 0, __pyx_mstate_global->__pyx_n_u_CDLIDENTICAL3CROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[61])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1766, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLIDENTICAL3CROWS, __pyx_t_2) < 0) __PYX_ERR(4, 1766, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_73CDLADVANCEBLOCK, 0, __pyx_mstate_global->__pyx_n_u_CDLADVANCEBLOCK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[38])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1024, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLADVANCEBLOCK, __pyx_t_3) < (0)) __PYX_ERR(4, 1024, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_121CDLINNECK, 0, __pyx_mstate_global->__pyx_n_u_CDLINNECK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[62])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1798, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLINNECK, __pyx_t_2) < 0) __PYX_ERR(4, 1798, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_75CDLBELTHOLD, 0, __pyx_mstate_global->__pyx_n_u_CDLBELTHOLD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[39])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1056, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLBELTHOLD, __pyx_t_3) < (0)) __PYX_ERR(4, 1056, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_123CDLINVERTEDHAMMER, 0, __pyx_mstate_global->__pyx_n_u_CDLINVERTEDHAMMER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[63])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1830, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLINVERTEDHAMMER, __pyx_t_2) < 0) __PYX_ERR(4, 1830, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_77CDLBREAKAWAY, 0, __pyx_mstate_global->__pyx_n_u_CDLBREAKAWAY, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[40])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1088, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLBREAKAWAY, __pyx_t_3) < (0)) __PYX_ERR(4, 1088, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_125CDLKICKING, 0, __pyx_mstate_global->__pyx_n_u_CDLKICKING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[64])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1862, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLKICKING, __pyx_t_2) < 0) __PYX_ERR(4, 1862, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_79CDLCLOSINGMARUBOZU, 0, __pyx_mstate_global->__pyx_n_u_CDLCLOSINGMARUBOZU, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[41])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1120, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLCLOSINGMARUBOZU, __pyx_t_3) < (0)) __PYX_ERR(4, 1120, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_127CDLKICKINGBYLENGTH, 0, __pyx_mstate_global->__pyx_n_u_CDLKICKINGBYLENGTH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[65])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1894, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLKICKINGBYLENGTH, __pyx_t_2) < 0) __PYX_ERR(4, 1894, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_81CDLCONCEALBABYSWALL, 0, __pyx_mstate_global->__pyx_n_u_CDLCONCEALBABYSWALL, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[42])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLCONCEALBABYSWALL, __pyx_t_3) < (0)) __PYX_ERR(4, 1152, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_129CDLLADDERBOTTOM, 0, __pyx_mstate_global->__pyx_n_u_CDLLADDERBOTTOM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[66])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1926, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLLADDERBOTTOM, __pyx_t_2) < 0) __PYX_ERR(4, 1926, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_83CDLCOUNTERATTACK, 0, __pyx_mstate_global->__pyx_n_u_CDLCOUNTERATTACK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[43])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLCOUNTERATTACK, __pyx_t_3) < (0)) __PYX_ERR(4, 1184, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_131CDLLONGLEGGEDDOJI, 0, __pyx_mstate_global->__pyx_n_u_CDLLONGLEGGEDDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[67])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1958, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLLONGLEGGEDDOJI, __pyx_t_2) < 0) __PYX_ERR(4, 1958, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = PyFloat_FromDouble(((double)0.5)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_133CDLLONGLINE, 0, __pyx_mstate_global->__pyx_n_u_CDLLONGLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[68])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1990, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLLONGLINE, __pyx_t_2) < 0) __PYX_ERR(4, 1990, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 1216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_85CDLDARKCLOUDCOVER, 0, __pyx_mstate_global->__pyx_n_u_CDLDARKCLOUDCOVER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[44])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLDARKCLOUDCOVER, __pyx_t_3) < (0)) __PYX_ERR(4, 1216, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_135CDLMARUBOZU, 0, __pyx_mstate_global->__pyx_n_u_CDLMARUBOZU, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[69])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2022, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLMARUBOZU, __pyx_t_2) < 0) __PYX_ERR(4, 2022, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_87CDLDOJI, 0, __pyx_mstate_global->__pyx_n_u_CDLDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[45])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLDOJI, __pyx_t_3) < (0)) __PYX_ERR(4, 1250, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_137CDLMATCHINGLOW, 0, __pyx_mstate_global->__pyx_n_u_CDLMATCHINGLOW, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[70])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2054, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLMATCHINGLOW, __pyx_t_2) < 0) __PYX_ERR(4, 2054, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_89CDLDOJISTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLDOJISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[46])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1282, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLDOJISTAR, __pyx_t_3) < (0)) __PYX_ERR(4, 1282, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = PyFloat_FromDouble(((double)0.5)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2088, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_91CDLDRAGONFLYDOJI, 0, __pyx_mstate_global->__pyx_n_u_CDLDRAGONFLYDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[47])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLDRAGONFLYDOJI, __pyx_t_3) < (0)) __PYX_ERR(4, 1314, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2086, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_139CDLMATHOLD, 0, __pyx_mstate_global->__pyx_n_u_CDLMATHOLD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[71])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2086, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16); - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLMATHOLD, __pyx_t_2) < 0) __PYX_ERR(4, 2086, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_93CDLENGULFING, 0, __pyx_mstate_global->__pyx_n_u_CDLENGULFING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[48])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1346, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLENGULFING, __pyx_t_3) < (0)) __PYX_ERR(4, 1346, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2122, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2120, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 1378, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_141CDLMORNINGDOJISTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLMORNINGDOJISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[72])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2120, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_95CDLEVENINGDOJISTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLEVENINGDOJISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[49])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1378, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLMORNINGDOJISTAR, __pyx_t_2) < 0) __PYX_ERR(4, 2120, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLEVENINGDOJISTAR, __pyx_t_3) < (0)) __PYX_ERR(4, 1378, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2156, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2154, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 1412, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_143CDLMORNINGSTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLMORNINGSTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[73])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2154, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_97CDLEVENINGSTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLEVENINGSTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[50])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLMORNINGSTAR, __pyx_t_2) < 0) __PYX_ERR(4, 2154, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLEVENINGSTAR, __pyx_t_3) < (0)) __PYX_ERR(4, 1412, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_145CDLONNECK, 0, __pyx_mstate_global->__pyx_n_u_CDLONNECK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[74])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2188, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLONNECK, __pyx_t_2) < 0) __PYX_ERR(4, 2188, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_99CDLGAPSIDESIDEWHITE, 0, __pyx_mstate_global->__pyx_n_u_CDLGAPSIDESIDEWHITE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[51])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1446, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLGAPSIDESIDEWHITE, __pyx_t_3) < (0)) __PYX_ERR(4, 1446, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_147CDLPIERCING, 0, __pyx_mstate_global->__pyx_n_u_CDLPIERCING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[75])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLPIERCING, __pyx_t_2) < 0) __PYX_ERR(4, 2220, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_101CDLGRAVESTONEDOJI, 0, __pyx_mstate_global->__pyx_n_u_CDLGRAVESTONEDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[52])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1478, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLGRAVESTONEDOJI, __pyx_t_3) < (0)) __PYX_ERR(4, 1478, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_149CDLRICKSHAWMAN, 0, __pyx_mstate_global->__pyx_n_u_CDLRICKSHAWMAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[76])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2252, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLRICKSHAWMAN, __pyx_t_2) < 0) __PYX_ERR(4, 2252, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_103CDLHAMMER, 0, __pyx_mstate_global->__pyx_n_u_CDLHAMMER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[53])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHAMMER, __pyx_t_3) < (0)) __PYX_ERR(4, 1510, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_151CDLRISEFALL3METHODS, 0, __pyx_mstate_global->__pyx_n_u_CDLRISEFALL3METHODS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[77])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2284, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLRISEFALL3METHODS, __pyx_t_2) < 0) __PYX_ERR(4, 2284, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_105CDLHANGINGMAN, 0, __pyx_mstate_global->__pyx_n_u_CDLHANGINGMAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[54])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1542, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHANGINGMAN, __pyx_t_3) < (0)) __PYX_ERR(4, 1542, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_153CDLSEPARATINGLINES, 0, __pyx_mstate_global->__pyx_n_u_CDLSEPARATINGLINES, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[78])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2316, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSEPARATINGLINES, __pyx_t_2) < 0) __PYX_ERR(4, 2316, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_107CDLHARAMI, 0, __pyx_mstate_global->__pyx_n_u_CDLHARAMI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[55])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHARAMI, __pyx_t_3) < (0)) __PYX_ERR(4, 1574, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_155CDLSHOOTINGSTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLSHOOTINGSTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[79])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2348, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSHOOTINGSTAR, __pyx_t_2) < 0) __PYX_ERR(4, 2348, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_109CDLHARAMICROSS, 0, __pyx_mstate_global->__pyx_n_u_CDLHARAMICROSS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[56])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1606, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHARAMICROSS, __pyx_t_3) < (0)) __PYX_ERR(4, 1606, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_157CDLSHORTLINE, 0, __pyx_mstate_global->__pyx_n_u_CDLSHORTLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[80])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2380, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSHORTLINE, __pyx_t_2) < 0) __PYX_ERR(4, 2380, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_111CDLHIGHWAVE, 0, __pyx_mstate_global->__pyx_n_u_CDLHIGHWAVE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[57])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1638, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHIGHWAVE, __pyx_t_3) < (0)) __PYX_ERR(4, 1638, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_159CDLSPINNINGTOP, 0, __pyx_mstate_global->__pyx_n_u_CDLSPINNINGTOP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[81])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2412, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSPINNINGTOP, __pyx_t_2) < 0) __PYX_ERR(4, 2412, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_113CDLHIKKAKE, 0, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[58])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1670, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKE, __pyx_t_3) < (0)) __PYX_ERR(4, 1670, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_161CDLSTALLEDPATTERN, 0, __pyx_mstate_global->__pyx_n_u_CDLSTALLEDPATTERN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[82])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2444, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSTALLEDPATTERN, __pyx_t_2) < 0) __PYX_ERR(4, 2444, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_115CDLHIKKAKEMOD, 0, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKEMOD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[59])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1702, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKEMOD, __pyx_t_3) < (0)) __PYX_ERR(4, 1702, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_163CDLSTICKSANDWICH, 0, __pyx_mstate_global->__pyx_n_u_CDLSTICKSANDWICH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[83])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2476, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSTICKSANDWICH, __pyx_t_2) < 0) __PYX_ERR(4, 2476, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_117CDLHOMINGPIGEON, 0, __pyx_mstate_global->__pyx_n_u_CDLHOMINGPIGEON, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[60])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1734, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHOMINGPIGEON, __pyx_t_3) < (0)) __PYX_ERR(4, 1734, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_165CDLTAKURI, 0, __pyx_mstate_global->__pyx_n_u_CDLTAKURI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[84])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2508, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLTAKURI, __pyx_t_2) < 0) __PYX_ERR(4, 2508, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_119CDLIDENTICAL3CROWS, 0, __pyx_mstate_global->__pyx_n_u_CDLIDENTICAL3CROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[61])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1766, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLIDENTICAL3CROWS, __pyx_t_3) < (0)) __PYX_ERR(4, 1766, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_167CDLTASUKIGAP, 0, __pyx_mstate_global->__pyx_n_u_CDLTASUKIGAP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[85])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2540, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLTASUKIGAP, __pyx_t_2) < 0) __PYX_ERR(4, 2540, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_121CDLINNECK, 0, __pyx_mstate_global->__pyx_n_u_CDLINNECK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[62])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1798, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLINNECK, __pyx_t_3) < (0)) __PYX_ERR(4, 1798, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_169CDLTHRUSTING, 0, __pyx_mstate_global->__pyx_n_u_CDLTHRUSTING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[86])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2572, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLTHRUSTING, __pyx_t_2) < 0) __PYX_ERR(4, 2572, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_123CDLINVERTEDHAMMER, 0, __pyx_mstate_global->__pyx_n_u_CDLINVERTEDHAMMER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[63])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1830, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLINVERTEDHAMMER, __pyx_t_3) < (0)) __PYX_ERR(4, 1830, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_171CDLTRISTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLTRISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[87])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2604, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLTRISTAR, __pyx_t_2) < 0) __PYX_ERR(4, 2604, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_125CDLKICKING, 0, __pyx_mstate_global->__pyx_n_u_CDLKICKING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[64])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1862, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLKICKING, __pyx_t_3) < (0)) __PYX_ERR(4, 1862, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_173CDLUNIQUE3RIVER, 0, __pyx_mstate_global->__pyx_n_u_CDLUNIQUE3RIVER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[88])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2636, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLUNIQUE3RIVER, __pyx_t_2) < 0) __PYX_ERR(4, 2636, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_127CDLKICKINGBYLENGTH, 0, __pyx_mstate_global->__pyx_n_u_CDLKICKINGBYLENGTH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[65])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1894, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLKICKINGBYLENGTH, __pyx_t_3) < (0)) __PYX_ERR(4, 1894, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_175CDLUPSIDEGAP2CROWS, 0, __pyx_mstate_global->__pyx_n_u_CDLUPSIDEGAP2CROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[89])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2668, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLUPSIDEGAP2CROWS, __pyx_t_2) < 0) __PYX_ERR(4, 2668, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_129CDLLADDERBOTTOM, 0, __pyx_mstate_global->__pyx_n_u_CDLLADDERBOTTOM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[66])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1926, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLLADDERBOTTOM, __pyx_t_3) < (0)) __PYX_ERR(4, 1926, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_177CDLXSIDEGAP3METHODS, 0, __pyx_mstate_global->__pyx_n_u_CDLXSIDEGAP3METHODS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[90])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2700, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLXSIDEGAP3METHODS, __pyx_t_2) < 0) __PYX_ERR(4, 2700, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_131CDLLONGLEGGEDDOJI, 0, __pyx_mstate_global->__pyx_n_u_CDLLONGLEGGEDDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[67])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1958, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLLONGLEGGEDDOJI, __pyx_t_3) < (0)) __PYX_ERR(4, 1958, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_179CEIL, 0, __pyx_mstate_global->__pyx_n_u_CEIL, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[91])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2732, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CEIL, __pyx_t_2) < 0) __PYX_ERR(4, 2732, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_133CDLLONGLINE, 0, __pyx_mstate_global->__pyx_n_u_CDLLONGLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[68])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1990, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLLONGLINE, __pyx_t_3) < (0)) __PYX_ERR(4, 1990, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2763, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_135CDLMARUBOZU, 0, __pyx_mstate_global->__pyx_n_u_CDLMARUBOZU, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[69])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2022, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLMARUBOZU, __pyx_t_3) < (0)) __PYX_ERR(4, 2022, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_137CDLMATCHINGLOW, 0, __pyx_mstate_global->__pyx_n_u_CDLMATCHINGLOW, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[70])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2054, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLMATCHINGLOW, __pyx_t_3) < (0)) __PYX_ERR(4, 2054, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = PyFloat_FromDouble(((double)0.5)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2088, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2761, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2086, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_181CMO, 0, __pyx_mstate_global->__pyx_n_u_CMO, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[92])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2761, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_139CDLMATHOLD, 0, __pyx_mstate_global->__pyx_n_u_CDLMATHOLD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[71])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2086, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CMO, __pyx_t_2) < 0) __PYX_ERR(4, 2761, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLMATHOLD, __pyx_t_3) < (0)) __PYX_ERR(4, 2086, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2794, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2792, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_183CORREL, 0, __pyx_mstate_global->__pyx_n_u_CORREL, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[93])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2792, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_141CDLMORNINGDOJISTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLMORNINGDOJISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[72])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2120, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CORREL, __pyx_t_2) < 0) __PYX_ERR(4, 2792, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLMORNINGDOJISTAR, __pyx_t_3) < (0)) __PYX_ERR(4, 2120, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_185COS, 0, __pyx_mstate_global->__pyx_n_u_COS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[94])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2825, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_COS, __pyx_t_2) < 0) __PYX_ERR(4, 2825, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_187COSH, 0, __pyx_mstate_global->__pyx_n_u_COSH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[95])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2854, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_COSH, __pyx_t_2) < 0) __PYX_ERR(4, 2854, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_143CDLMORNINGSTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLMORNINGSTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[73])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLMORNINGSTAR, __pyx_t_3) < (0)) __PYX_ERR(4, 2154, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2885, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_145CDLONNECK, 0, __pyx_mstate_global->__pyx_n_u_CDLONNECK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[74])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLONNECK, __pyx_t_3) < (0)) __PYX_ERR(4, 2188, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_147CDLPIERCING, 0, __pyx_mstate_global->__pyx_n_u_CDLPIERCING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[75])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLPIERCING, __pyx_t_3) < (0)) __PYX_ERR(4, 2220, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_149CDLRICKSHAWMAN, 0, __pyx_mstate_global->__pyx_n_u_CDLRICKSHAWMAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[76])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLRICKSHAWMAN, __pyx_t_3) < (0)) __PYX_ERR(4, 2252, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_151CDLRISEFALL3METHODS, 0, __pyx_mstate_global->__pyx_n_u_CDLRISEFALL3METHODS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[77])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLRISEFALL3METHODS, __pyx_t_3) < (0)) __PYX_ERR(4, 2284, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_153CDLSEPARATINGLINES, 0, __pyx_mstate_global->__pyx_n_u_CDLSEPARATINGLINES, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[78])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2316, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSEPARATINGLINES, __pyx_t_3) < (0)) __PYX_ERR(4, 2316, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_155CDLSHOOTINGSTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLSHOOTINGSTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[79])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSHOOTINGSTAR, __pyx_t_3) < (0)) __PYX_ERR(4, 2348, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_157CDLSHORTLINE, 0, __pyx_mstate_global->__pyx_n_u_CDLSHORTLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[80])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSHORTLINE, __pyx_t_3) < (0)) __PYX_ERR(4, 2380, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_159CDLSPINNINGTOP, 0, __pyx_mstate_global->__pyx_n_u_CDLSPINNINGTOP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[81])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSPINNINGTOP, __pyx_t_3) < (0)) __PYX_ERR(4, 2412, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_161CDLSTALLEDPATTERN, 0, __pyx_mstate_global->__pyx_n_u_CDLSTALLEDPATTERN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[82])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2444, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSTALLEDPATTERN, __pyx_t_3) < (0)) __PYX_ERR(4, 2444, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_163CDLSTICKSANDWICH, 0, __pyx_mstate_global->__pyx_n_u_CDLSTICKSANDWICH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[83])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSTICKSANDWICH, __pyx_t_3) < (0)) __PYX_ERR(4, 2476, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_165CDLTAKURI, 0, __pyx_mstate_global->__pyx_n_u_CDLTAKURI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[84])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2508, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLTAKURI, __pyx_t_3) < (0)) __PYX_ERR(4, 2508, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_167CDLTASUKIGAP, 0, __pyx_mstate_global->__pyx_n_u_CDLTASUKIGAP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[85])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2540, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLTASUKIGAP, __pyx_t_3) < (0)) __PYX_ERR(4, 2540, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_169CDLTHRUSTING, 0, __pyx_mstate_global->__pyx_n_u_CDLTHRUSTING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[86])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLTHRUSTING, __pyx_t_3) < (0)) __PYX_ERR(4, 2572, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_171CDLTRISTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLTRISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[87])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2604, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLTRISTAR, __pyx_t_3) < (0)) __PYX_ERR(4, 2604, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_173CDLUNIQUE3RIVER, 0, __pyx_mstate_global->__pyx_n_u_CDLUNIQUE3RIVER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[88])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2636, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLUNIQUE3RIVER, __pyx_t_3) < (0)) __PYX_ERR(4, 2636, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_175CDLUPSIDEGAP2CROWS, 0, __pyx_mstate_global->__pyx_n_u_CDLUPSIDEGAP2CROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[89])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2668, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLUPSIDEGAP2CROWS, __pyx_t_3) < (0)) __PYX_ERR(4, 2668, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_177CDLXSIDEGAP3METHODS, 0, __pyx_mstate_global->__pyx_n_u_CDLXSIDEGAP3METHODS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[90])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLXSIDEGAP3METHODS, __pyx_t_3) < (0)) __PYX_ERR(4, 2700, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_179CEIL, 0, __pyx_mstate_global->__pyx_n_u_CEIL, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[91])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2732, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CEIL, __pyx_t_3) < (0)) __PYX_ERR(4, 2732, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2883, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2763, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2761, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_189DEMA, 0, __pyx_mstate_global->__pyx_n_u_DEMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[96])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2883, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_181CMO, 0, __pyx_mstate_global->__pyx_n_u_CMO, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[92])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2761, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_DEMA, __pyx_t_2) < 0) __PYX_ERR(4, 2883, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CMO, __pyx_t_3) < (0)) __PYX_ERR(4, 2761, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_191DIV, 0, __pyx_mstate_global->__pyx_n_u_DIV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[97])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2914, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_DIV, __pyx_t_2) < 0) __PYX_ERR(4, 2914, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2794, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2947, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2792, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_183CORREL, 0, __pyx_mstate_global->__pyx_n_u_CORREL, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[93])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2792, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CORREL, __pyx_t_3) < (0)) __PYX_ERR(4, 2792, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_185COS, 0, __pyx_mstate_global->__pyx_n_u_COS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[94])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2825, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_COS, __pyx_t_3) < (0)) __PYX_ERR(4, 2825, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_187COSH, 0, __pyx_mstate_global->__pyx_n_u_COSH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[95])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2854, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_COSH, __pyx_t_3) < (0)) __PYX_ERR(4, 2854, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2885, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2945, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_193DX, 0, __pyx_mstate_global->__pyx_n_u_DX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[98])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2945, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_189DEMA, 0, __pyx_mstate_global->__pyx_n_u_DEMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[96])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2883, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_DX, __pyx_t_2) < 0) __PYX_ERR(4, 2945, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_DEMA, __pyx_t_3) < (0)) __PYX_ERR(4, 2883, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2980, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_191DIV, 0, __pyx_mstate_global->__pyx_n_u_DIV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[97])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_DIV, __pyx_t_3) < (0)) __PYX_ERR(4, 2914, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2978, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2947, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2945, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_195EMA, 0, __pyx_mstate_global->__pyx_n_u_EMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[99])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2978, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_193DX, 0, __pyx_mstate_global->__pyx_n_u_DX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[98])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2945, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_EMA, __pyx_t_2) < 0) __PYX_ERR(4, 2978, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_DX, __pyx_t_3) < (0)) __PYX_ERR(4, 2945, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_197EXP, 0, __pyx_mstate_global->__pyx_n_u_EXP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[100])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3009, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_EXP, __pyx_t_2) < 0) __PYX_ERR(4, 3009, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2980, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_199FLOOR, 0, __pyx_mstate_global->__pyx_n_u_FLOOR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[101])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3038, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_FLOOR, __pyx_t_2) < 0) __PYX_ERR(4, 3038, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2978, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_195EMA, 0, __pyx_mstate_global->__pyx_n_u_EMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[99])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2978, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_EMA, __pyx_t_3) < (0)) __PYX_ERR(4, 2978, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_201HT_DCPERIOD, 0, __pyx_mstate_global->__pyx_n_u_HT_DCPERIOD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[102])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3067, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_DCPERIOD, __pyx_t_2) < 0) __PYX_ERR(4, 3067, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_197EXP, 0, __pyx_mstate_global->__pyx_n_u_EXP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[100])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3009, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_EXP, __pyx_t_3) < (0)) __PYX_ERR(4, 3009, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_203HT_DCPHASE, 0, __pyx_mstate_global->__pyx_n_u_HT_DCPHASE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[103])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3096, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_DCPHASE, __pyx_t_2) < 0) __PYX_ERR(4, 3096, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_199FLOOR, 0, __pyx_mstate_global->__pyx_n_u_FLOOR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[101])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3038, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_FLOOR, __pyx_t_3) < (0)) __PYX_ERR(4, 3038, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_205HT_PHASOR, 0, __pyx_mstate_global->__pyx_n_u_HT_PHASOR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[104])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3125, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_PHASOR, __pyx_t_2) < 0) __PYX_ERR(4, 3125, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_201HT_DCPERIOD, 0, __pyx_mstate_global->__pyx_n_u_HT_DCPERIOD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[102])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3067, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_DCPERIOD, __pyx_t_3) < (0)) __PYX_ERR(4, 3067, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_207HT_SINE, 0, __pyx_mstate_global->__pyx_n_u_HT_SINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[105])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_SINE, __pyx_t_2) < 0) __PYX_ERR(4, 3157, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_203HT_DCPHASE, 0, __pyx_mstate_global->__pyx_n_u_HT_DCPHASE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[103])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3096, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_DCPHASE, __pyx_t_3) < (0)) __PYX_ERR(4, 3096, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_209HT_TRENDLINE, 0, __pyx_mstate_global->__pyx_n_u_HT_TRENDLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[106])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3189, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_TRENDLINE, __pyx_t_2) < 0) __PYX_ERR(4, 3189, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_205HT_PHASOR, 0, __pyx_mstate_global->__pyx_n_u_HT_PHASOR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[104])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_PHASOR, __pyx_t_3) < (0)) __PYX_ERR(4, 3125, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_211HT_TRENDMODE, 0, __pyx_mstate_global->__pyx_n_u_HT_TRENDMODE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[107])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3218, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_TRENDMODE, __pyx_t_2) < 0) __PYX_ERR(4, 3218, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_207HT_SINE, 0, __pyx_mstate_global->__pyx_n_u_HT_SINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[105])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_SINE, __pyx_t_3) < (0)) __PYX_ERR(4, 3157, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_209HT_TRENDLINE, 0, __pyx_mstate_global->__pyx_n_u_HT_TRENDLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[106])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_TRENDLINE, __pyx_t_3) < (0)) __PYX_ERR(4, 3189, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_211HT_TRENDMODE, 0, __pyx_mstate_global->__pyx_n_u_HT_TRENDMODE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[107])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_TRENDMODE, __pyx_t_3) < (0)) __PYX_ERR(4, 3218, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3247, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3247, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_213IMI, 0, __pyx_mstate_global->__pyx_n_u_IMI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[108])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3247, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_213IMI, 0, __pyx_mstate_global->__pyx_n_u_IMI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[108])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3247, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_IMI, __pyx_t_2) < 0) __PYX_ERR(4, 3247, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_IMI, __pyx_t_3) < (0)) __PYX_ERR(4, 3247, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3281, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3279, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3279, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_215KAMA, 0, __pyx_mstate_global->__pyx_n_u_KAMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[109])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3279, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_215KAMA, 0, __pyx_mstate_global->__pyx_n_u_KAMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[109])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3279, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_KAMA, __pyx_t_2) < 0) __PYX_ERR(4, 3279, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_KAMA, __pyx_t_3) < (0)) __PYX_ERR(4, 3279, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3312, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3312, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3310, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3310, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_217LINEARREG, 0, __pyx_mstate_global->__pyx_n_u_LINEARREG, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[110])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3310, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_217LINEARREG, 0, __pyx_mstate_global->__pyx_n_u_LINEARREG, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[110])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3310, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_LINEARREG, __pyx_t_2) < 0) __PYX_ERR(4, 3310, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_LINEARREG, __pyx_t_3) < (0)) __PYX_ERR(4, 3310, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3343, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3341, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3341, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_219LINEARREG_ANGLE, 0, __pyx_mstate_global->__pyx_n_u_LINEARREG_ANGLE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[111])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3341, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_219LINEARREG_ANGLE, 0, __pyx_mstate_global->__pyx_n_u_LINEARREG_ANGLE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[111])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3341, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_LINEARREG_ANGLE, __pyx_t_2) < 0) __PYX_ERR(4, 3341, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_LINEARREG_ANGLE, __pyx_t_3) < (0)) __PYX_ERR(4, 3341, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3374, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3374, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3372, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3372, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_221LINEARREG_INTERCEPT, 0, __pyx_mstate_global->__pyx_n_u_LINEARREG_INTERCEPT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[112])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3372, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_221LINEARREG_INTERCEPT, 0, __pyx_mstate_global->__pyx_n_u_LINEARREG_INTERCEPT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[112])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3372, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_LINEARREG_INTERCEPT, __pyx_t_2) < 0) __PYX_ERR(4, 3372, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_LINEARREG_INTERCEPT, __pyx_t_3) < (0)) __PYX_ERR(4, 3372, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3405, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3403, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3403, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_223LINEARREG_SLOPE, 0, __pyx_mstate_global->__pyx_n_u_LINEARREG_SLOPE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[113])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3403, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_223LINEARREG_SLOPE, 0, __pyx_mstate_global->__pyx_n_u_LINEARREG_SLOPE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[113])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_LINEARREG_SLOPE, __pyx_t_2) < 0) __PYX_ERR(4, 3403, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_LINEARREG_SLOPE, __pyx_t_3) < (0)) __PYX_ERR(4, 3403, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_225LN, 0, __pyx_mstate_global->__pyx_n_u_LN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[114])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3434, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_LN, __pyx_t_2) < 0) __PYX_ERR(4, 3434, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_225LN, 0, __pyx_mstate_global->__pyx_n_u_LN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[114])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_LN, __pyx_t_3) < (0)) __PYX_ERR(4, 3434, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_227LOG10, 0, __pyx_mstate_global->__pyx_n_u_LOG10, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[115])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3463, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_LOG10, __pyx_t_2) < 0) __PYX_ERR(4, 3463, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_227LOG10, 0, __pyx_mstate_global->__pyx_n_u_LOG10, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[115])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3463, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_LOG10, __pyx_t_3) < (0)) __PYX_ERR(4, 3463, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3494, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_16 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3494, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __pyx_t_4 = PyTuple_Pack(2, __pyx_t_2, __pyx_t_16); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 3492, __pyx_L1_error) + __pyx_t_4 = PyTuple_Pack(2, __pyx_t_3, __pyx_t_16); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 3492, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_229MA, 0, __pyx_mstate_global->__pyx_n_u_MA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[116])); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3492, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_16); + #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_16, __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MA, __pyx_t_16) < 0) __PYX_ERR(4, 3492, __pyx_L1_error) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MA, __pyx_t_16) < (0)) __PYX_ERR(4, 3492, __pyx_L1_error) __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_16 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3526, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 3526, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3526, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3526, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_15 = PyTuple_Pack(3, __pyx_t_16, __pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 3524, __pyx_L1_error) + __pyx_t_15 = PyTuple_Pack(3, __pyx_t_16, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 3524, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_231MACD, 0, __pyx_mstate_global->__pyx_n_u_MACD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[117])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3524, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_15); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_231MACD, 0, __pyx_mstate_global->__pyx_n_u_MACD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[117])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3524, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MACD, __pyx_t_2) < 0) __PYX_ERR(4, 3524, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MACD, __pyx_t_3) < (0)) __PYX_ERR(4, 3524, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3565, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3565, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_15 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 3565, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 3565, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_16 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3565, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3565, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_20 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3565, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - - __pyx_t_19 = PyTuple_Pack(6, __pyx_t_2, __pyx_t_15, __pyx_t_4, __pyx_t_16, __pyx_t_3, __pyx_t_20); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3563, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3565, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3565, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_20 = PyTuple_Pack(6, __pyx_t_3, __pyx_t_15, __pyx_t_4, __pyx_t_16, __pyx_t_2, __pyx_t_19); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3563, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_20); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_233MACDEXT, 0, __pyx_mstate_global->__pyx_n_u_MACDEXT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[118])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3563, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_19); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MACDEXT, __pyx_t_20) < 0) __PYX_ERR(4, 3563, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3607, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - - __pyx_t_19 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3605, __pyx_L1_error) + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_233MACDEXT, 0, __pyx_mstate_global->__pyx_n_u_MACDEXT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[118])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3563, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_20); __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_235MACDFIX, 0, __pyx_mstate_global->__pyx_n_u_MACDFIX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[119])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3605, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_19); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MACDEXT, __pyx_t_19) < (0)) __PYX_ERR(4, 3563, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MACDFIX, __pyx_t_20) < 0) __PYX_ERR(4, 3605, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3644, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __pyx_t_19 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3644, __pyx_L1_error) + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3607, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); - __pyx_t_3 = PyTuple_Pack(2, __pyx_t_20, __pyx_t_19); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3642, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __pyx_t_20 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_20); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_237MAMA, 0, __pyx_mstate_global->__pyx_n_u_MAMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[120])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3642, __pyx_L1_error) + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_235MACDFIX, 0, __pyx_mstate_global->__pyx_n_u_MACDFIX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[119])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3605, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MAMA, __pyx_t_19) < 0) __PYX_ERR(4, 3642, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_20); + __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MACDFIX, __pyx_t_19) < (0)) __PYX_ERR(4, 3605, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3679, __pyx_L1_error) + __pyx_t_19 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3644, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3679, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_20 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3679, __pyx_L1_error) + __pyx_t_20 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3644, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_20); - __pyx_t_16 = PyTuple_Pack(3, __pyx_t_19, __pyx_t_3, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3677, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_16); + __pyx_t_2 = PyTuple_Pack(2, __pyx_t_19, __pyx_t_20); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3642, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_239MAVP, 0, __pyx_mstate_global->__pyx_n_u_MAVP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[121])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3677, __pyx_L1_error) + __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_237MAMA, 0, __pyx_mstate_global->__pyx_n_u_MAMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[120])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3642, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_20); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16); - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MAVP, __pyx_t_20) < 0) __PYX_ERR(4, 3677, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_20); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MAMA, __pyx_t_20) < (0)) __PYX_ERR(4, 3642, __pyx_L1_error) __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3714, __pyx_L1_error) + __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3679, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_20); + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3679, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3679, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3712, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(3, __pyx_t_20, __pyx_t_2, __pyx_t_19); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3677, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_241MAX, 0, __pyx_mstate_global->__pyx_n_u_MAX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[122])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3712, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_239MAVP, 0, __pyx_mstate_global->__pyx_n_u_MAVP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[121])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3677, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MAX, __pyx_t_20) < 0) __PYX_ERR(4, 3712, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MAVP, __pyx_t_19) < (0)) __PYX_ERR(4, 3677, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3745, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3714, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3743, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3712, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_243MAXINDEX, 0, __pyx_mstate_global->__pyx_n_u_MAXINDEX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[123])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3743, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_241MAX, 0, __pyx_mstate_global->__pyx_n_u_MAX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[122])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3712, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MAXINDEX, __pyx_t_20) < 0) __PYX_ERR(4, 3743, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_245MEDPRICE, 0, __pyx_mstate_global->__pyx_n_u_MEDPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[124])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3777, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MEDPRICE, __pyx_t_20) < 0) __PYX_ERR(4, 3777, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MAX, __pyx_t_19) < (0)) __PYX_ERR(4, 3712, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3809, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3745, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3807, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3743, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_247MFI, 0, __pyx_mstate_global->__pyx_n_u_MFI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[125])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3807, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_243MAXINDEX, 0, __pyx_mstate_global->__pyx_n_u_MAXINDEX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[123])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3743, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MFI, __pyx_t_20) < 0) __PYX_ERR(4, 3807, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MAXINDEX, __pyx_t_19) < (0)) __PYX_ERR(4, 3743, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3843, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_245MEDPRICE, 0, __pyx_mstate_global->__pyx_n_u_MEDPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[124])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3777, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MEDPRICE, __pyx_t_19) < (0)) __PYX_ERR(4, 3777, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3809, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3841, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3807, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_249MIDPOINT, 0, __pyx_mstate_global->__pyx_n_u_MIDPOINT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[126])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3841, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_247MFI, 0, __pyx_mstate_global->__pyx_n_u_MFI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[125])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3807, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MIDPOINT, __pyx_t_20) < 0) __PYX_ERR(4, 3841, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MFI, __pyx_t_19) < (0)) __PYX_ERR(4, 3807, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3874, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3843, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3872, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3841, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_251MIDPRICE, 0, __pyx_mstate_global->__pyx_n_u_MIDPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[127])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3872, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_249MIDPOINT, 0, __pyx_mstate_global->__pyx_n_u_MIDPOINT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[126])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3841, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MIDPRICE, __pyx_t_20) < 0) __PYX_ERR(4, 3872, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MIDPOINT, __pyx_t_19) < (0)) __PYX_ERR(4, 3841, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3906, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3874, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3904, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3872, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_253MIN, 0, __pyx_mstate_global->__pyx_n_u_MIN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[128])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3904, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_251MIDPRICE, 0, __pyx_mstate_global->__pyx_n_u_MIDPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[127])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3872, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MIN, __pyx_t_20) < 0) __PYX_ERR(4, 3904, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MIDPRICE, __pyx_t_19) < (0)) __PYX_ERR(4, 3872, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3937, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3906, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3935, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3904, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_255MININDEX, 0, __pyx_mstate_global->__pyx_n_u_MININDEX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[129])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3935, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_253MIN, 0, __pyx_mstate_global->__pyx_n_u_MIN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[128])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3904, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MININDEX, __pyx_t_20) < 0) __PYX_ERR(4, 3935, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MIN, __pyx_t_19) < (0)) __PYX_ERR(4, 3904, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3971, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3937, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3969, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3935, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_257MINMAX, 0, __pyx_mstate_global->__pyx_n_u_MINMAX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[130])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3969, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_255MININDEX, 0, __pyx_mstate_global->__pyx_n_u_MININDEX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[129])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3935, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINMAX, __pyx_t_20) < 0) __PYX_ERR(4, 3969, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MININDEX, __pyx_t_19) < (0)) __PYX_ERR(4, 3935, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4005, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3971, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4003, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3969, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_259MINMAXINDEX, 0, __pyx_mstate_global->__pyx_n_u_MINMAXINDEX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[131])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4003, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_257MINMAX, 0, __pyx_mstate_global->__pyx_n_u_MINMAX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[130])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3969, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINMAXINDEX, __pyx_t_20) < 0) __PYX_ERR(4, 4003, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINMAX, __pyx_t_19) < (0)) __PYX_ERR(4, 3969, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4045, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4005, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4043, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4003, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_261MINUS_DI, 0, __pyx_mstate_global->__pyx_n_u_MINUS_DI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[132])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4043, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_259MINMAXINDEX, 0, __pyx_mstate_global->__pyx_n_u_MINMAXINDEX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[131])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4003, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINUS_DI, __pyx_t_20) < 0) __PYX_ERR(4, 4043, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINMAXINDEX, __pyx_t_19) < (0)) __PYX_ERR(4, 4003, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4078, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4045, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4076, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4043, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_263MINUS_DM, 0, __pyx_mstate_global->__pyx_n_u_MINUS_DM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[133])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4076, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_261MINUS_DI, 0, __pyx_mstate_global->__pyx_n_u_MINUS_DI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[132])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4043, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINUS_DM, __pyx_t_20) < 0) __PYX_ERR(4, 4076, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINUS_DI, __pyx_t_19) < (0)) __PYX_ERR(4, 4043, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4078, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4108, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4076, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_265MOM, 0, __pyx_mstate_global->__pyx_n_u_MOM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[134])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4108, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_263MINUS_DM, 0, __pyx_mstate_global->__pyx_n_u_MINUS_DM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[133])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4076, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MOM, __pyx_t_20) < 0) __PYX_ERR(4, 4108, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_267MULT, 0, __pyx_mstate_global->__pyx_n_u_MULT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[135])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4139, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MULT, __pyx_t_20) < 0) __PYX_ERR(4, 4139, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINUS_DM, __pyx_t_19) < (0)) __PYX_ERR(4, 4076, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4172, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4170, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4108, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_269NATR, 0, __pyx_mstate_global->__pyx_n_u_NATR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[136])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4170, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_265MOM, 0, __pyx_mstate_global->__pyx_n_u_MOM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[134])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_NATR, __pyx_t_20) < 0) __PYX_ERR(4, 4170, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MOM, __pyx_t_19) < (0)) __PYX_ERR(4, 4108, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_271OBV, 0, __pyx_mstate_global->__pyx_n_u_OBV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[137])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4203, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_OBV, __pyx_t_20) < 0) __PYX_ERR(4, 4203, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_267MULT, 0, __pyx_mstate_global->__pyx_n_u_MULT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[135])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MULT, __pyx_t_19) < (0)) __PYX_ERR(4, 4139, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4236, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4234, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_273PLUS_DI, 0, __pyx_mstate_global->__pyx_n_u_PLUS_DI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[138])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4234, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_269NATR, 0, __pyx_mstate_global->__pyx_n_u_NATR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[136])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PLUS_DI, __pyx_t_20) < 0) __PYX_ERR(4, 4234, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_NATR, __pyx_t_19) < (0)) __PYX_ERR(4, 4170, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4269, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_271OBV, 0, __pyx_mstate_global->__pyx_n_u_OBV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[137])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4203, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_OBV, __pyx_t_19) < (0)) __PYX_ERR(4, 4203, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4267, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_275PLUS_DM, 0, __pyx_mstate_global->__pyx_n_u_PLUS_DM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[139])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4267, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16); - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PLUS_DM, __pyx_t_20) < 0) __PYX_ERR(4, 4267, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4301, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __pyx_t_16 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4301, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __pyx_t_3 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4301, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - - __pyx_t_19 = PyTuple_Pack(3, __pyx_t_20, __pyx_t_16, __pyx_t_3); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4299, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_273PLUS_DI, 0, __pyx_mstate_global->__pyx_n_u_PLUS_DI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[138])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_277PPO, 0, __pyx_mstate_global->__pyx_n_u_PPO, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[140])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4299, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_19); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PLUS_DI, __pyx_t_19) < (0)) __PYX_ERR(4, 4234, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PPO, __pyx_t_3) < 0) __PYX_ERR(4, 4299, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4334, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4269, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_19 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4332, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_275PLUS_DM, 0, __pyx_mstate_global->__pyx_n_u_PLUS_DM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[139])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4267, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_279ROC, 0, __pyx_mstate_global->__pyx_n_u_ROC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[141])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4332, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_16); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PLUS_DM, __pyx_t_19) < (0)) __PYX_ERR(4, 4267, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ROC, __pyx_t_3) < 0) __PYX_ERR(4, 4332, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4365, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - - __pyx_t_19 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4363, __pyx_L1_error) + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_281ROCP, 0, __pyx_mstate_global->__pyx_n_u_ROCP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[142])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4363, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_19); + __pyx_t_16 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __pyx_t_2 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + __pyx_t_20 = PyTuple_Pack(3, __pyx_t_19, __pyx_t_16, __pyx_t_2); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_20); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ROCP, __pyx_t_3) < 0) __PYX_ERR(4, 4363, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_277PPO, 0, __pyx_mstate_global->__pyx_n_u_PPO, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[140])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_20); + __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PPO, __pyx_t_2) < (0)) __PYX_ERR(4, 4299, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4396, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4334, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); - __pyx_t_19 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4394, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_19); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_283ROCR, 0, __pyx_mstate_global->__pyx_n_u_ROCR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[143])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4394, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_19); - __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ROCR, __pyx_t_3) < 0) __PYX_ERR(4, 4394, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_20 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4332, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_20); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_279ROC, 0, __pyx_mstate_global->__pyx_n_u_ROC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[141])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4332, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_20); + __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ROC, __pyx_t_2) < (0)) __PYX_ERR(4, 4332, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4427, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4365, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); - __pyx_t_19 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4425, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_19); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_285ROCR100, 0, __pyx_mstate_global->__pyx_n_u_ROCR100, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[144])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4425, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_19); - __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ROCR100, __pyx_t_3) < 0) __PYX_ERR(4, 4425, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_20 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_20); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_281ROCP, 0, __pyx_mstate_global->__pyx_n_u_ROCP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[142])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_20); + __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ROCP, __pyx_t_2) < (0)) __PYX_ERR(4, 4363, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4458, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4396, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); - __pyx_t_19 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4456, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_19); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_287RSI, 0, __pyx_mstate_global->__pyx_n_u_RSI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[145])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4456, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_19); - __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_RSI, __pyx_t_3) < 0) __PYX_ERR(4, 4456, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_20 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4394, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_20); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_283ROCR, 0, __pyx_mstate_global->__pyx_n_u_ROCR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[143])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4394, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_20); + __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ROCR, __pyx_t_2) < (0)) __PYX_ERR(4, 4394, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = PyFloat_FromDouble(((double)0.02)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4489, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_19 = PyFloat_FromDouble(((double)0.2)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4489, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_19); + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + __pyx_t_20 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_20); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_285ROCR100, 0, __pyx_mstate_global->__pyx_n_u_ROCR100, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[144])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_20); + __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ROCR100, __pyx_t_2) < (0)) __PYX_ERR(4, 4425, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4458, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + __pyx_t_20 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4456, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_20); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_287RSI, 0, __pyx_mstate_global->__pyx_n_u_RSI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[145])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4456, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_20); + __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_RSI, __pyx_t_2) < (0)) __PYX_ERR(4, 4456, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_16 = PyTuple_Pack(2, __pyx_t_3, __pyx_t_19); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4487, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble(((double)0.02)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_20 = PyFloat_FromDouble(((double)0.2)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_20); + + __pyx_t_16 = PyTuple_Pack(2, __pyx_t_2, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4487, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_289SAR, 0, __pyx_mstate_global->__pyx_n_u_SAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[146])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4487, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_19); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_16); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_289SAR, 0, __pyx_mstate_global->__pyx_n_u_SAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[146])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4487, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_20); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_20); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SAR, __pyx_t_19) < 0) __PYX_ERR(4, 4487, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SAR, __pyx_t_20) < (0)) __PYX_ERR(4, 4487, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_19 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4522, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_19); - __pyx_t_16 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4522, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_16); - __pyx_t_3 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4522, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); __pyx_t_20 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4522, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_20); + __pyx_t_16 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __pyx_t_2 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_19 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); __pyx_t_4 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4522, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_15 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 4522, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); - __pyx_t_2 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4522, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4522, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - - __pyx_t_6 = PyTuple_Pack(8, __pyx_t_19, __pyx_t_16, __pyx_t_3, __pyx_t_20, __pyx_t_4, __pyx_t_15, __pyx_t_2, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4520, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4522, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_8 = PyTuple_Pack(8, __pyx_t_20, __pyx_t_16, __pyx_t_2, __pyx_t_19, __pyx_t_4, __pyx_t_15, __pyx_t_3, __pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 4520, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_291SAREXT, 0, __pyx_mstate_global->__pyx_n_u_SAREXT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[147])); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4520, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_291SAREXT, 0, __pyx_mstate_global->__pyx_n_u_SAREXT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[147])); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4520, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SAREXT, __pyx_t_6) < (0)) __PYX_ERR(4, 4520, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SAREXT, __pyx_t_7) < 0) __PYX_ERR(4, 4520, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_293SIN, 0, __pyx_mstate_global->__pyx_n_u_SIN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[148])); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4559, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SIN, __pyx_t_7) < 0) __PYX_ERR(4, 4559, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_295SINH, 0, __pyx_mstate_global->__pyx_n_u_SINH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[149])); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4588, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SINH, __pyx_t_7) < 0) __PYX_ERR(4, 4588, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4619, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_293SIN, 0, __pyx_mstate_global->__pyx_n_u_SIN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[148])); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4559, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SIN, __pyx_t_6) < (0)) __PYX_ERR(4, 4559, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4617, __pyx_L1_error) + __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_295SINH, 0, __pyx_mstate_global->__pyx_n_u_SINH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[149])); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4588, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_297SMA, 0, __pyx_mstate_global->__pyx_n_u_SMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[150])); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4617, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SINH, __pyx_t_6) < (0)) __PYX_ERR(4, 4588, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SMA, __pyx_t_7) < 0) __PYX_ERR(4, 4617, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_299SQRT, 0, __pyx_mstate_global->__pyx_n_u_SQRT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[151])); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4648, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SQRT, __pyx_t_7) < 0) __PYX_ERR(4, 4648, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4619, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4679, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4679, __pyx_L1_error) + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 4617, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_297SMA, 0, __pyx_mstate_global->__pyx_n_u_SMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[150])); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4617, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SMA, __pyx_t_6) < (0)) __PYX_ERR(4, 4617, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_2 = PyTuple_Pack(2, __pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4677, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_299SQRT, 0, __pyx_mstate_global->__pyx_n_u_SQRT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[151])); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4648, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SQRT, __pyx_t_6) < (0)) __PYX_ERR(4, 4648, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_301STDDEV, 0, __pyx_mstate_global->__pyx_n_u_STDDEV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[152])); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4677, __pyx_L1_error) + + __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4679, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_2); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_STDDEV, __pyx_t_6) < 0) __PYX_ERR(4, 4677, __pyx_L1_error) + __pyx_t_8 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 4679, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + + __pyx_t_3 = PyTuple_Pack(2, __pyx_t_6, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4677, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_301STDDEV, 0, __pyx_mstate_global->__pyx_n_u_STDDEV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[152])); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 4677, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_8); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_8, __pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_STDDEV, __pyx_t_8) < (0)) __PYX_ERR(4, 4677, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4711, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 4711, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4711, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4711, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4711, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4711, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); __pyx_t_15 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 4711, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __pyx_t_4 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4711, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_20 = PyTuple_Pack(5, __pyx_t_6, __pyx_t_2, __pyx_t_7, __pyx_t_15, __pyx_t_4); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4709, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_19 = PyTuple_Pack(5, __pyx_t_8, __pyx_t_3, __pyx_t_6, __pyx_t_15, __pyx_t_4); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4709, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_303STOCH, 0, __pyx_mstate_global->__pyx_n_u_STOCH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[153])); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4709, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_20); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_STOCH, __pyx_t_4) < 0) __PYX_ERR(4, 4709, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_19); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_STOCH, __pyx_t_4) < (0)) __PYX_ERR(4, 4709, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4751, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4751, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4751, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); __pyx_t_15 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 4751, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); - __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_20, __pyx_t_15); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4749, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_19, __pyx_t_15); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4749, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_305STOCHF, 0, __pyx_mstate_global->__pyx_n_u_STOCHF, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[154])); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 4749, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_15, __pyx_t_7); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_STOCHF, __pyx_t_15) < 0) __PYX_ERR(4, 4749, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_15); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_15, __pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_STOCHF, __pyx_t_15) < (0)) __PYX_ERR(4, 4749, __pyx_L1_error) __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __pyx_t_15 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 4789, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4789, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4789, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4789, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4789, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); __pyx_t_4 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4789, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 = PyTuple_Pack(4, __pyx_t_15, __pyx_t_7, __pyx_t_20, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4787, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_Pack(4, __pyx_t_15, __pyx_t_6, __pyx_t_19, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4787, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_307STOCHRSI, 0, __pyx_mstate_global->__pyx_n_u_STOCHRSI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[155])); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4787, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_2); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_STOCHRSI, __pyx_t_4) < 0) __PYX_ERR(4, 4787, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_STOCHRSI, __pyx_t_4) < (0)) __PYX_ERR(4, 4787, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_309SUB, 0, __pyx_mstate_global->__pyx_n_u_SUB, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[156])); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4824, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SUB, __pyx_t_4) < 0) __PYX_ERR(4, 4824, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SUB, __pyx_t_4) < (0)) __PYX_ERR(4, 4824, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4857, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4855, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4855, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_311SUM, 0, __pyx_mstate_global->__pyx_n_u_SUM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[157])); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4855, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_2); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SUM, __pyx_t_4) < 0) __PYX_ERR(4, 4855, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SUM, __pyx_t_4) < (0)) __PYX_ERR(4, 4855, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4888, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4888, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4888, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_20 = PyTuple_Pack(2, __pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4886, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_19 = PyTuple_Pack(2, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4886, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_313T3, 0, __pyx_mstate_global->__pyx_n_u_T3, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[158])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4886, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_20); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_T3, __pyx_t_2) < 0) __PYX_ERR(4, 4886, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_313T3, 0, __pyx_mstate_global->__pyx_n_u_T3, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[158])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4886, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_19); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_T3, __pyx_t_3) < (0)) __PYX_ERR(4, 4886, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_315TAN, 0, __pyx_mstate_global->__pyx_n_u_TAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[159])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4918, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TAN, __pyx_t_2) < 0) __PYX_ERR(4, 4918, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_315TAN, 0, __pyx_mstate_global->__pyx_n_u_TAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[159])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4918, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TAN, __pyx_t_3) < (0)) __PYX_ERR(4, 4918, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_317TANH, 0, __pyx_mstate_global->__pyx_n_u_TANH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[160])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4947, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TANH, __pyx_t_2) < 0) __PYX_ERR(4, 4947, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_317TANH, 0, __pyx_mstate_global->__pyx_n_u_TANH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[160])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4947, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TANH, __pyx_t_3) < (0)) __PYX_ERR(4, 4947, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4978, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4978, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_20 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4976, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_319TEMA, 0, __pyx_mstate_global->__pyx_n_u_TEMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[161])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4976, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_20); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TEMA, __pyx_t_2) < 0) __PYX_ERR(4, 4976, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_19 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4976, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_319TEMA, 0, __pyx_mstate_global->__pyx_n_u_TEMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[161])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4976, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_19); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TEMA, __pyx_t_3) < (0)) __PYX_ERR(4, 4976, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_321TRANGE, 0, __pyx_mstate_global->__pyx_n_u_TRANGE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[162])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 5007, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TRANGE, __pyx_t_2) < 0) __PYX_ERR(4, 5007, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_321TRANGE, 0, __pyx_mstate_global->__pyx_n_u_TRANGE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[162])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 5007, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TRANGE, __pyx_t_3) < (0)) __PYX_ERR(4, 5007, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 5040, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 5040, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_20 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 5038, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_323TRIMA, 0, __pyx_mstate_global->__pyx_n_u_TRIMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[163])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 5038, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_20); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TRIMA, __pyx_t_2) < 0) __PYX_ERR(4, 5038, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_19 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 5038, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_323TRIMA, 0, __pyx_mstate_global->__pyx_n_u_TRIMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[163])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 5038, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_19); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TRIMA, __pyx_t_3) < (0)) __PYX_ERR(4, 5038, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 5071, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 5071, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_20 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 5069, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_325TRIX, 0, __pyx_mstate_global->__pyx_n_u_TRIX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[164])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 5069, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_20); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TRIX, __pyx_t_2) < 0) __PYX_ERR(4, 5069, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_19 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 5069, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_325TRIX, 0, __pyx_mstate_global->__pyx_n_u_TRIX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[164])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 5069, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_19); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TRIX, __pyx_t_3) < (0)) __PYX_ERR(4, 5069, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 5102, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 5102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); - __pyx_t_20 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 5100, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_327TSF, 0, __pyx_mstate_global->__pyx_n_u_TSF, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[165])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 5100, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_20); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TSF, __pyx_t_2) < 0) __PYX_ERR(4, 5100, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_19 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 5100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_327TSF, 0, __pyx_mstate_global->__pyx_n_u_TSF, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[165])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 5100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_19); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TSF, __pyx_t_3) < (0)) __PYX_ERR(4, 5100, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_329TYPPRICE, 0, __pyx_mstate_global->__pyx_n_u_TYPPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[166])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 5131, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TYPPRICE, __pyx_t_2) < 0) __PYX_ERR(4, 5131, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_329TYPPRICE, 0, __pyx_mstate_global->__pyx_n_u_TYPPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[166])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 5131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TYPPRICE, __pyx_t_3) < (0)) __PYX_ERR(4, 5131, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 5164, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 5164, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 5164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 5164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 5164, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_7 = PyTuple_Pack(3, __pyx_t_2, __pyx_t_20, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 5162, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __pyx_t_6 = PyTuple_Pack(3, __pyx_t_3, __pyx_t_19, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 5162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_331ULTOSC, 0, __pyx_mstate_global->__pyx_n_u_ULTOSC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[167])); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 5162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_7); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ULTOSC, __pyx_t_4) < 0) __PYX_ERR(4, 5162, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ULTOSC, __pyx_t_4) < (0)) __PYX_ERR(4, 5162, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 5199, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_7 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 5199, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 5199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); - __pyx_t_20 = PyTuple_Pack(2, __pyx_t_4, __pyx_t_7); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 5197, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_19 = PyTuple_Pack(2, __pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 5197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_333VAR, 0, __pyx_mstate_global->__pyx_n_u_VAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[168])); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 5197, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_20); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_VAR, __pyx_t_7) < 0) __PYX_ERR(4, 5197, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_333VAR, 0, __pyx_mstate_global->__pyx_n_u_VAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[168])); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 5197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_19); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_VAR, __pyx_t_6) < (0)) __PYX_ERR(4, 5197, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_335WCLPRICE, 0, __pyx_mstate_global->__pyx_n_u_WCLPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[169])); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 5229, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_WCLPRICE, __pyx_t_7) < 0) __PYX_ERR(4, 5229, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_335WCLPRICE, 0, __pyx_mstate_global->__pyx_n_u_WCLPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[169])); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 5229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_WCLPRICE, __pyx_t_6) < (0)) __PYX_ERR(4, 5229, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 5262, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 5262, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); - __pyx_t_20 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 5260, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_337WILLR, 0, __pyx_mstate_global->__pyx_n_u_WILLR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[170])); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 5260, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_20); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_WILLR, __pyx_t_7) < 0) __PYX_ERR(4, 5260, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = PyTuple_Pack(1, __pyx_t_6); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 5260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_337WILLR, 0, __pyx_mstate_global->__pyx_n_u_WILLR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[170])); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 5260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_19); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_WILLR, __pyx_t_6) < (0)) __PYX_ERR(4, 5260, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 5295, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 5295, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); - __pyx_t_20 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 5293, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_339WMA, 0, __pyx_mstate_global->__pyx_n_u_WMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[171])); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 5293, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_20); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_WMA, __pyx_t_7) < 0) __PYX_ERR(4, 5293, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = PyTuple_Pack(1, __pyx_t_6); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 5293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_339WMA, 0, __pyx_mstate_global->__pyx_n_u_WMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[171])); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 5293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_19); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_WMA, __pyx_t_6) < (0)) __PYX_ERR(4, 5293, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_7 = __Pyx_PyList_Pack(161, __pyx_mstate_global->__pyx_n_u_ACCBANDS, __pyx_mstate_global->__pyx_n_u_ACOS, __pyx_mstate_global->__pyx_n_u_AD, __pyx_mstate_global->__pyx_n_u_ADD, __pyx_mstate_global->__pyx_n_u_ADOSC, __pyx_mstate_global->__pyx_n_u_ADX, __pyx_mstate_global->__pyx_n_u_ADXR, __pyx_mstate_global->__pyx_n_u_APO, __pyx_mstate_global->__pyx_n_u_AROON, __pyx_mstate_global->__pyx_n_u_AROONOSC, __pyx_mstate_global->__pyx_n_u_ASIN, __pyx_mstate_global->__pyx_n_u_ATAN, __pyx_mstate_global->__pyx_n_u_ATR, __pyx_mstate_global->__pyx_n_u_AVGPRICE, __pyx_mstate_global->__pyx_n_u_AVGDEV, __pyx_mstate_global->__pyx_n_u_BBANDS, __pyx_mstate_global->__pyx_n_u_BETA, __pyx_mstate_global->__pyx_n_u_BOP, __pyx_mstate_global->__pyx_n_u_CCI, __pyx_mstate_global->__pyx_n_u_CDL2CROWS, __pyx_mstate_global->__pyx_n_u_CDL3BLACKCROWS, __pyx_mstate_global->__pyx_n_u_CDL3INSIDE, __pyx_mstate_global->__pyx_n_u_CDL3LINESTRIKE, __pyx_mstate_global->__pyx_n_u_CDL3OUTSIDE, __pyx_mstate_global->__pyx_n_u_CDL3STARSINSOUTH, __pyx_mstate_global->__pyx_n_u_CDL3WHITESOLDIERS, __pyx_mstate_global->__pyx_n_u_CDLABANDONEDBABY, __pyx_mstate_global->__pyx_n_u_CDLADVANCEBLOCK, __pyx_mstate_global->__pyx_n_u_CDLBELTHOLD, __pyx_mstate_global->__pyx_n_u_CDLBREAKAWAY, __pyx_mstate_global->__pyx_n_u_CDLCLOSINGMARUBOZU, __pyx_mstate_global->__pyx_n_u_CDLCONCEALBABYSWALL, __pyx_mstate_global->__pyx_n_u_CDLCOUNTERATTACK, __pyx_mstate_global->__pyx_n_u_CDLDARKCLOUDCOVER, __pyx_mstate_global->__pyx_n_u_CDLDOJI, __pyx_mstate_global->__pyx_n_u_CDLDOJISTAR, __pyx_mstate_global->__pyx_n_u_CDLDRAGONFLYDOJI, __pyx_mstate_global->__pyx_n_u_CDLENGULFING, __pyx_mstate_global->__pyx_n_u_CDLEVENINGDOJISTAR, __pyx_mstate_global->__pyx_n_u_CDLEVENINGSTAR, __pyx_mstate_global->__pyx_n_u_CDLGAPSIDESIDEWHITE, __pyx_mstate_global->__pyx_n_u_CDLGRAVESTONEDOJI, __pyx_mstate_global->__pyx_n_u_CDLHAMMER, __pyx_mstate_global->__pyx_n_u_CDLHANGINGMAN, __pyx_mstate_global->__pyx_n_u_CDLHARAMI, __pyx_mstate_global->__pyx_n_u_CDLHARAMICROSS, __pyx_mstate_global->__pyx_n_u_CDLHIGHWAVE, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKE, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKEMOD, __pyx_mstate_global->__pyx_n_u_CDLHOMINGPIGEON, __pyx_mstate_global->__pyx_n_u_CDLIDENTICAL3CROWS, __pyx_mstate_global->__pyx_n_u_CDLINNECK, __pyx_mstate_global->__pyx_n_u_CDLINVERTEDHAMMER, __pyx_mstate_global->__pyx_n_u_CDLKICKING, __pyx_mstate_global->__pyx_n_u_CDLKICKINGBYLENGTH, __pyx_mstate_global->__pyx_n_u_CDLLADDERBOTTOM, __pyx_mstate_global->__pyx_n_u_CDLLONGLEGGEDDOJI, __pyx_mstate_global->__pyx_n_u_CDLLONGLINE, __pyx_mstate_global->__pyx_n_u_CDLMARUBOZU, __pyx_mstate_global->__pyx_n_u_CDLMATCHINGLOW, __pyx_mstate_global->__pyx_n_u_CDLMATHOLD, __pyx_mstate_global->__pyx_n_u_CDLMORNINGDOJISTAR, __pyx_mstate_global->__pyx_n_u_CDLMORNINGSTAR, __pyx_mstate_global->__pyx_n_u_CDLONNECK, __pyx_mstate_global->__pyx_n_u_CDLPIERCING, __pyx_mstate_global->__pyx_n_u_CDLRICKSHAWMAN, __pyx_mstate_global->__pyx_n_u_CDLRISEFALL3METHODS, __pyx_mstate_global->__pyx_n_u_CDLSEPARATINGLINES, __pyx_mstate_global->__pyx_n_u_CDLSHOOTINGSTAR, __pyx_mstate_global->__pyx_n_u_CDLSHORTLINE, __pyx_mstate_global->__pyx_n_u_CDLSPINNINGTOP, __pyx_mstate_global->__pyx_n_u_CDLSTALLEDPATTERN, __pyx_mstate_global->__pyx_n_u_CDLSTICKSANDWICH, __pyx_mstate_global->__pyx_n_u_CDLTAKURI, __pyx_mstate_global->__pyx_n_u_CDLTASUKIGAP, __pyx_mstate_global->__pyx_n_u_CDLTHRUSTING, __pyx_mstate_global->__pyx_n_u_CDLTRISTAR, __pyx_mstate_global->__pyx_n_u_CDLUNIQUE3RIVER, __pyx_mstate_global->__pyx_n_u_CDLUPSIDEGAP2CROWS, __pyx_mstate_global->__pyx_n_u_CDLXSIDEGAP3METHODS, __pyx_mstate_global->__pyx_n_u_CEIL, __pyx_mstate_global->__pyx_n_u_CMO, __pyx_mstate_global->__pyx_n_u_CORREL, __pyx_mstate_global->__pyx_n_u_COS, __pyx_mstate_global->__pyx_n_u_COSH, __pyx_mstate_global->__pyx_n_u_DEMA, __pyx_mstate_global->__pyx_n_u_DIV, __pyx_mstate_global->__pyx_n_u_DX, __pyx_mstate_global->__pyx_n_u_EMA, __pyx_mstate_global->__pyx_n_u_EXP, __pyx_mstate_global->__pyx_n_u_FLOOR, __pyx_mstate_global->__pyx_n_u_HT_DCPERIOD, __pyx_mstate_global->__pyx_n_u_HT_DCPHASE, __pyx_mstate_global->__pyx_n_u_HT_PHASOR, __pyx_mstate_global->__pyx_n_u_HT_SINE, __pyx_mstate_global->__pyx_n_u_HT_TRENDLINE, __pyx_mstate_global->__pyx_n_u_HT_TRENDMODE, __pyx_mstate_global->__pyx_n_u_IMI, __pyx_mstate_global->__pyx_n_u_KAMA, __pyx_mstate_global->__pyx_n_u_LINEARREG, __pyx_mstate_global->__pyx_n_u_LINEARREG_ANGLE, __pyx_mstate_global->__pyx_n_u_LINEARREG_INTERCEPT, __pyx_mstate_global->__pyx_n_u_LINEARREG_SLOPE, __pyx_mstate_global->__pyx_n_u_LN, __pyx_mstate_global->__pyx_n_u_LOG10, __pyx_mstate_global->__pyx_n_u_MA, __pyx_mstate_global->__pyx_n_u_MACD, __pyx_mstate_global->__pyx_n_u_MACDEXT, __pyx_mstate_global->__pyx_n_u_MACDFIX, __pyx_mstate_global->__pyx_n_u_MAMA, __pyx_mstate_global->__pyx_n_u_MAVP, __pyx_mstate_global->__pyx_n_u_MAX, __pyx_mstate_global->__pyx_n_u_MAXINDEX, __pyx_mstate_global->__pyx_n_u_MEDPRICE, __pyx_mstate_global->__pyx_n_u_MFI, __pyx_mstate_global->__pyx_n_u_MIDPOINT, __pyx_mstate_global->__pyx_n_u_MIDPRICE, __pyx_mstate_global->__pyx_n_u_MIN, __pyx_mstate_global->__pyx_n_u_MININDEX, __pyx_mstate_global->__pyx_n_u_MINMAX, __pyx_mstate_global->__pyx_n_u_MINMAXINDEX, __pyx_mstate_global->__pyx_n_u_MINUS_DI, __pyx_mstate_global->__pyx_n_u_MINUS_DM, __pyx_mstate_global->__pyx_n_u_MOM, __pyx_mstate_global->__pyx_n_u_MULT, __pyx_mstate_global->__pyx_n_u_NATR, __pyx_mstate_global->__pyx_n_u_OBV, __pyx_mstate_global->__pyx_n_u_PLUS_DI, __pyx_mstate_global->__pyx_n_u_PLUS_DM, __pyx_mstate_global->__pyx_n_u_PPO, __pyx_mstate_global->__pyx_n_u_ROC, __pyx_mstate_global->__pyx_n_u_ROCP, __pyx_mstate_global->__pyx_n_u_ROCR, __pyx_mstate_global->__pyx_n_u_ROCR100, __pyx_mstate_global->__pyx_n_u_RSI, __pyx_mstate_global->__pyx_n_u_SAR, __pyx_mstate_global->__pyx_n_u_SAREXT, __pyx_mstate_global->__pyx_n_u_SIN, __pyx_mstate_global->__pyx_n_u_SINH, __pyx_mstate_global->__pyx_n_u_SMA, __pyx_mstate_global->__pyx_n_u_SQRT, __pyx_mstate_global->__pyx_n_u_STDDEV, __pyx_mstate_global->__pyx_n_u_STOCH, __pyx_mstate_global->__pyx_n_u_STOCHF, __pyx_mstate_global->__pyx_n_u_STOCHRSI, __pyx_mstate_global->__pyx_n_u_SUB, __pyx_mstate_global->__pyx_n_u_SUM, __pyx_mstate_global->__pyx_n_u_T3, __pyx_mstate_global->__pyx_n_u_TAN, __pyx_mstate_global->__pyx_n_u_TANH, __pyx_mstate_global->__pyx_n_u_TEMA, __pyx_mstate_global->__pyx_n_u_TRANGE, __pyx_mstate_global->__pyx_n_u_TRIMA, __pyx_mstate_global->__pyx_n_u_TRIX, __pyx_mstate_global->__pyx_n_u_TSF, __pyx_mstate_global->__pyx_n_u_TYPPRICE, __pyx_mstate_global->__pyx_n_u_ULTOSC, __pyx_mstate_global->__pyx_n_u_VAR, __pyx_mstate_global->__pyx_n_u_WCLPRICE, __pyx_mstate_global->__pyx_n_u_WILLR, __pyx_mstate_global->__pyx_n_u_WMA); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 5324, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TA_FUNCTION_NAMES, __pyx_t_7) < 0) __PYX_ERR(4, 5324, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_6 = __Pyx_PyList_Pack(161, __pyx_mstate_global->__pyx_n_u_ACCBANDS, __pyx_mstate_global->__pyx_n_u_ACOS, __pyx_mstate_global->__pyx_n_u_AD, __pyx_mstate_global->__pyx_n_u_ADD, __pyx_mstate_global->__pyx_n_u_ADOSC, __pyx_mstate_global->__pyx_n_u_ADX, __pyx_mstate_global->__pyx_n_u_ADXR, __pyx_mstate_global->__pyx_n_u_APO, __pyx_mstate_global->__pyx_n_u_AROON, __pyx_mstate_global->__pyx_n_u_AROONOSC, __pyx_mstate_global->__pyx_n_u_ASIN, __pyx_mstate_global->__pyx_n_u_ATAN, __pyx_mstate_global->__pyx_n_u_ATR, __pyx_mstate_global->__pyx_n_u_AVGPRICE, __pyx_mstate_global->__pyx_n_u_AVGDEV, __pyx_mstate_global->__pyx_n_u_BBANDS, __pyx_mstate_global->__pyx_n_u_BETA, __pyx_mstate_global->__pyx_n_u_BOP, __pyx_mstate_global->__pyx_n_u_CCI, __pyx_mstate_global->__pyx_n_u_CDL2CROWS, __pyx_mstate_global->__pyx_n_u_CDL3BLACKCROWS, __pyx_mstate_global->__pyx_n_u_CDL3INSIDE, __pyx_mstate_global->__pyx_n_u_CDL3LINESTRIKE, __pyx_mstate_global->__pyx_n_u_CDL3OUTSIDE, __pyx_mstate_global->__pyx_n_u_CDL3STARSINSOUTH, __pyx_mstate_global->__pyx_n_u_CDL3WHITESOLDIERS, __pyx_mstate_global->__pyx_n_u_CDLABANDONEDBABY, __pyx_mstate_global->__pyx_n_u_CDLADVANCEBLOCK, __pyx_mstate_global->__pyx_n_u_CDLBELTHOLD, __pyx_mstate_global->__pyx_n_u_CDLBREAKAWAY, __pyx_mstate_global->__pyx_n_u_CDLCLOSINGMARUBOZU, __pyx_mstate_global->__pyx_n_u_CDLCONCEALBABYSWALL, __pyx_mstate_global->__pyx_n_u_CDLCOUNTERATTACK, __pyx_mstate_global->__pyx_n_u_CDLDARKCLOUDCOVER, __pyx_mstate_global->__pyx_n_u_CDLDOJI, __pyx_mstate_global->__pyx_n_u_CDLDOJISTAR, __pyx_mstate_global->__pyx_n_u_CDLDRAGONFLYDOJI, __pyx_mstate_global->__pyx_n_u_CDLENGULFING, __pyx_mstate_global->__pyx_n_u_CDLEVENINGDOJISTAR, __pyx_mstate_global->__pyx_n_u_CDLEVENINGSTAR, __pyx_mstate_global->__pyx_n_u_CDLGAPSIDESIDEWHITE, __pyx_mstate_global->__pyx_n_u_CDLGRAVESTONEDOJI, __pyx_mstate_global->__pyx_n_u_CDLHAMMER, __pyx_mstate_global->__pyx_n_u_CDLHANGINGMAN, __pyx_mstate_global->__pyx_n_u_CDLHARAMI, __pyx_mstate_global->__pyx_n_u_CDLHARAMICROSS, __pyx_mstate_global->__pyx_n_u_CDLHIGHWAVE, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKE, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKEMOD, __pyx_mstate_global->__pyx_n_u_CDLHOMINGPIGEON, __pyx_mstate_global->__pyx_n_u_CDLIDENTICAL3CROWS, __pyx_mstate_global->__pyx_n_u_CDLINNECK, __pyx_mstate_global->__pyx_n_u_CDLINVERTEDHAMMER, __pyx_mstate_global->__pyx_n_u_CDLKICKING, __pyx_mstate_global->__pyx_n_u_CDLKICKINGBYLENGTH, __pyx_mstate_global->__pyx_n_u_CDLLADDERBOTTOM, __pyx_mstate_global->__pyx_n_u_CDLLONGLEGGEDDOJI, __pyx_mstate_global->__pyx_n_u_CDLLONGLINE, __pyx_mstate_global->__pyx_n_u_CDLMARUBOZU, __pyx_mstate_global->__pyx_n_u_CDLMATCHINGLOW, __pyx_mstate_global->__pyx_n_u_CDLMATHOLD, __pyx_mstate_global->__pyx_n_u_CDLMORNINGDOJISTAR, __pyx_mstate_global->__pyx_n_u_CDLMORNINGSTAR, __pyx_mstate_global->__pyx_n_u_CDLONNECK, __pyx_mstate_global->__pyx_n_u_CDLPIERCING, __pyx_mstate_global->__pyx_n_u_CDLRICKSHAWMAN, __pyx_mstate_global->__pyx_n_u_CDLRISEFALL3METHODS, __pyx_mstate_global->__pyx_n_u_CDLSEPARATINGLINES, __pyx_mstate_global->__pyx_n_u_CDLSHOOTINGSTAR, __pyx_mstate_global->__pyx_n_u_CDLSHORTLINE, __pyx_mstate_global->__pyx_n_u_CDLSPINNINGTOP, __pyx_mstate_global->__pyx_n_u_CDLSTALLEDPATTERN, __pyx_mstate_global->__pyx_n_u_CDLSTICKSANDWICH, __pyx_mstate_global->__pyx_n_u_CDLTAKURI, __pyx_mstate_global->__pyx_n_u_CDLTASUKIGAP, __pyx_mstate_global->__pyx_n_u_CDLTHRUSTING, __pyx_mstate_global->__pyx_n_u_CDLTRISTAR, __pyx_mstate_global->__pyx_n_u_CDLUNIQUE3RIVER, __pyx_mstate_global->__pyx_n_u_CDLUPSIDEGAP2CROWS, __pyx_mstate_global->__pyx_n_u_CDLXSIDEGAP3METHODS, __pyx_mstate_global->__pyx_n_u_CEIL, __pyx_mstate_global->__pyx_n_u_CMO, __pyx_mstate_global->__pyx_n_u_CORREL, __pyx_mstate_global->__pyx_n_u_COS, __pyx_mstate_global->__pyx_n_u_COSH, __pyx_mstate_global->__pyx_n_u_DEMA, __pyx_mstate_global->__pyx_n_u_DIV, __pyx_mstate_global->__pyx_n_u_DX, __pyx_mstate_global->__pyx_n_u_EMA, __pyx_mstate_global->__pyx_n_u_EXP, __pyx_mstate_global->__pyx_n_u_FLOOR, __pyx_mstate_global->__pyx_n_u_HT_DCPERIOD, __pyx_mstate_global->__pyx_n_u_HT_DCPHASE, __pyx_mstate_global->__pyx_n_u_HT_PHASOR, __pyx_mstate_global->__pyx_n_u_HT_SINE, __pyx_mstate_global->__pyx_n_u_HT_TRENDLINE, __pyx_mstate_global->__pyx_n_u_HT_TRENDMODE, __pyx_mstate_global->__pyx_n_u_IMI, __pyx_mstate_global->__pyx_n_u_KAMA, __pyx_mstate_global->__pyx_n_u_LINEARREG, __pyx_mstate_global->__pyx_n_u_LINEARREG_ANGLE, __pyx_mstate_global->__pyx_n_u_LINEARREG_INTERCEPT, __pyx_mstate_global->__pyx_n_u_LINEARREG_SLOPE, __pyx_mstate_global->__pyx_n_u_LN, __pyx_mstate_global->__pyx_n_u_LOG10, __pyx_mstate_global->__pyx_n_u_MA, __pyx_mstate_global->__pyx_n_u_MACD, __pyx_mstate_global->__pyx_n_u_MACDEXT, __pyx_mstate_global->__pyx_n_u_MACDFIX, __pyx_mstate_global->__pyx_n_u_MAMA, __pyx_mstate_global->__pyx_n_u_MAVP, __pyx_mstate_global->__pyx_n_u_MAX, __pyx_mstate_global->__pyx_n_u_MAXINDEX, __pyx_mstate_global->__pyx_n_u_MEDPRICE, __pyx_mstate_global->__pyx_n_u_MFI, __pyx_mstate_global->__pyx_n_u_MIDPOINT, __pyx_mstate_global->__pyx_n_u_MIDPRICE, __pyx_mstate_global->__pyx_n_u_MIN, __pyx_mstate_global->__pyx_n_u_MININDEX, __pyx_mstate_global->__pyx_n_u_MINMAX, __pyx_mstate_global->__pyx_n_u_MINMAXINDEX, __pyx_mstate_global->__pyx_n_u_MINUS_DI, __pyx_mstate_global->__pyx_n_u_MINUS_DM, __pyx_mstate_global->__pyx_n_u_MOM, __pyx_mstate_global->__pyx_n_u_MULT, __pyx_mstate_global->__pyx_n_u_NATR, __pyx_mstate_global->__pyx_n_u_OBV, __pyx_mstate_global->__pyx_n_u_PLUS_DI, __pyx_mstate_global->__pyx_n_u_PLUS_DM, __pyx_mstate_global->__pyx_n_u_PPO, __pyx_mstate_global->__pyx_n_u_ROC, __pyx_mstate_global->__pyx_n_u_ROCP, __pyx_mstate_global->__pyx_n_u_ROCR, __pyx_mstate_global->__pyx_n_u_ROCR100, __pyx_mstate_global->__pyx_n_u_RSI, __pyx_mstate_global->__pyx_n_u_SAR, __pyx_mstate_global->__pyx_n_u_SAREXT, __pyx_mstate_global->__pyx_n_u_SIN, __pyx_mstate_global->__pyx_n_u_SINH, __pyx_mstate_global->__pyx_n_u_SMA, __pyx_mstate_global->__pyx_n_u_SQRT, __pyx_mstate_global->__pyx_n_u_STDDEV, __pyx_mstate_global->__pyx_n_u_STOCH, __pyx_mstate_global->__pyx_n_u_STOCHF, __pyx_mstate_global->__pyx_n_u_STOCHRSI, __pyx_mstate_global->__pyx_n_u_SUB, __pyx_mstate_global->__pyx_n_u_SUM, __pyx_mstate_global->__pyx_n_u_T3, __pyx_mstate_global->__pyx_n_u_TAN, __pyx_mstate_global->__pyx_n_u_TANH, __pyx_mstate_global->__pyx_n_u_TEMA, __pyx_mstate_global->__pyx_n_u_TRANGE, __pyx_mstate_global->__pyx_n_u_TRIMA, __pyx_mstate_global->__pyx_n_u_TRIX, __pyx_mstate_global->__pyx_n_u_TSF, __pyx_mstate_global->__pyx_n_u_TYPPRICE, __pyx_mstate_global->__pyx_n_u_ULTOSC, __pyx_mstate_global->__pyx_n_u_VAR, __pyx_mstate_global->__pyx_n_u_WCLPRICE, __pyx_mstate_global->__pyx_n_u_WILLR, __pyx_mstate_global->__pyx_n_u_WMA); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 5324, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TA_FUNCTION_NAMES, __pyx_t_6) < (0)) __PYX_ERR(4, 5324, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_7 = __Pyx_ImportDottedModuleRelFirst(__pyx_mstate_global->__pyx_n_u_math, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_math, __pyx_t_7) < 0) __PYX_ERR(2, 4, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_math, 0, 0, __pyx_mstate_global->__pyx_kp_u_talib_math, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4, __pyx_L1_error) + __pyx_t_6 = __pyx_t_1; + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_math, __pyx_t_6) < (0)) __PYX_ERR(2, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_7 = __Pyx_ImportDottedModuleRelFirst(__pyx_mstate_global->__pyx_n_u_threading, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_threading, __pyx_t_7) < 0) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_threading, 0, 0, __pyx_mstate_global->__pyx_kp_u_talib_threading, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5, __pyx_L1_error) + __pyx_t_6 = __pyx_t_1; + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_threading, __pyx_t_6) < (0)) __PYX_ERR(2, 5, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; { __Pyx_PyThreadState_declare @@ -84326,16 +83757,22 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); __Pyx_XGOTREF(__pyx_t_25); /*try:*/ { - __pyx_t_7 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_OrderedDict); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 7, __pyx_L11_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_20 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_collections, __pyx_t_7, -1); if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 7, __pyx_L11_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_OrderedDict); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 7, __pyx_L11_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_OrderedDict, __pyx_t_7) < 0) __PYX_ERR(2, 7, __pyx_L11_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_OrderedDict}; + __pyx_t_26 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_collections, __pyx_imported_names, 1, __pyx_mstate_global->__pyx_kp_u_talib_collections, -1); if (unlikely(!__pyx_t_26)) __PYX_ERR(2, 7, __pyx_L11_error) + } + __pyx_t_6 = __pyx_t_26; + __Pyx_GOTREF(__pyx_t_6); + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_OrderedDict}; + __pyx_t_18 = 0; { + __pyx_t_19 = __Pyx_ImportFrom(__pyx_t_6, __pyx_imported_names[__pyx_t_18]); if (unlikely(!__pyx_t_19)) __PYX_ERR(2, 7, __pyx_L11_error) + __Pyx_GOTREF(__pyx_t_19); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_18], __pyx_t_19) < (0)) __PYX_ERR(2, 7, __pyx_L11_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + } + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -84358,29 +83795,35 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_23 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ImportError); + __pyx_t_23 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_ImportError)))); if (__pyx_t_23) { __Pyx_AddTraceback("talib._ta_lib", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_20, &__pyx_t_7, &__pyx_t_4) < 0) __PYX_ERR(2, 8, __pyx_L13_except_error) - __Pyx_XGOTREF(__pyx_t_20); - __Pyx_XGOTREF(__pyx_t_7); + if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_19, &__pyx_t_4) < 0) __PYX_ERR(2, 8, __pyx_L13_except_error) + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_19); __Pyx_XGOTREF(__pyx_t_4); - __pyx_t_2 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_OrderedDict); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 9, __pyx_L13_except_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_15 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_ordereddict, __pyx_t_2, -1); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 9, __pyx_L13_except_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_OrderedDict); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 9, __pyx_L13_except_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_OrderedDict, __pyx_t_2) < 0) __PYX_ERR(2, 9, __pyx_L13_except_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_OrderedDict}; + __pyx_t_26 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_ordereddict, __pyx_imported_names, 1, __pyx_mstate_global->__pyx_kp_u_talib_ordereddict, -1); if (unlikely(!__pyx_t_26)) __PYX_ERR(2, 9, __pyx_L13_except_error) + } + __pyx_t_3 = __pyx_t_26; + __Pyx_GOTREF(__pyx_t_3); + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_OrderedDict}; + __pyx_t_18 = 0; { + __pyx_t_15 = __Pyx_ImportFrom(__pyx_t_3, __pyx_imported_names[__pyx_t_18]); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 9, __pyx_L13_except_error) + __Pyx_GOTREF(__pyx_t_15); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_18], __pyx_t_15) < (0)) __PYX_ERR(2, 9, __pyx_L13_except_error) + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L12_exception_handled; } @@ -84400,35 +83843,37 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); __pyx_L16_try_end:; } - __pyx_t_4 = __Pyx_ImportDottedModuleRelFirst(__pyx_mstate_global->__pyx_n_u_numpy, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 11, __pyx_L1_error) + __pyx_t_25 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_numpy, 0, 0, __pyx_mstate_global->__pyx_kp_u_talib_numpy, -1); if (unlikely(!__pyx_t_25)) __PYX_ERR(2, 11, __pyx_L1_error) + __pyx_t_4 = __pyx_t_25; __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_numpy, __pyx_t_4) < 0) __PYX_ERR(2, 11, __pyx_L1_error) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_numpy, __pyx_t_4) < (0)) __PYX_ERR(2, 11, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_ImportDottedModuleRelFirst(__pyx_mstate_global->__pyx_n_u_sys, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 12, __pyx_L1_error) + __pyx_t_25 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_sys, 0, 0, __pyx_mstate_global->__pyx_kp_u_talib_sys, -1); if (unlikely(!__pyx_t_25)) __PYX_ERR(2, 12, __pyx_L1_error) + __pyx_t_4 = __pyx_t_25; __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_sys, __pyx_t_4) < 0) __PYX_ERR(2, 12, __pyx_L1_error) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_sys, __pyx_t_4) < (0)) __PYX_ERR(2, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_23 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_23 == ((int)-1))) __PYX_ERR(2, 18, __pyx_L1_error) __pyx_t_4 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 21, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_price, __pyx_mstate_global->__pyx_n_u_close) < 0) __PYX_ERR(2, 21, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_price0, __pyx_mstate_global->__pyx_n_u_high) < 0) __PYX_ERR(2, 21, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_price1, __pyx_mstate_global->__pyx_n_u_low) < 0) __PYX_ERR(2, 21, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_periods, __pyx_mstate_global->__pyx_n_u_periods) < 0) __PYX_ERR(2, 21, __pyx_L1_error) - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_INPUT_PRICE_SERIES_DEFAULTS, __pyx_t_4) < 0) __PYX_ERR(2, 21, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_price, __pyx_mstate_global->__pyx_n_u_close) < (0)) __PYX_ERR(2, 21, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_price0, __pyx_mstate_global->__pyx_n_u_high) < (0)) __PYX_ERR(2, 21, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_price1, __pyx_mstate_global->__pyx_n_u_low) < (0)) __PYX_ERR(2, 21, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_periods, __pyx_mstate_global->__pyx_n_u_periods) < (0)) __PYX_ERR(2, 21, __pyx_L1_error) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_INPUT_PRICE_SERIES_DEFAULTS, __pyx_t_4) < (0)) __PYX_ERR(2, 21, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyList_Pack(1, ((PyObject *)(&PyDict_Type))); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 27, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_INPUT_ARRAYS_TYPES, __pyx_t_4) < 0) __PYX_ERR(2, 27, __pyx_L1_error) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_INPUT_ARRAYS_TYPES, __pyx_t_4) < (0)) __PYX_ERR(2, 27, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyList_Pack(1, ((PyObject *)__pyx_mstate_global->__pyx_ptype_5numpy_ndarray)); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 28, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ARRAY_TYPES, __pyx_t_4) < 0) __PYX_ERR(2, 28, __pyx_L1_error) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ARRAY_TYPES, __pyx_t_4) < (0)) __PYX_ERR(2, 28, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; { @@ -84440,48 +83885,49 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); __Pyx_XGOTREF(__pyx_t_1); /*try:*/ { - __pyx_t_4 = __Pyx_ImportDottedModuleRelFirst(__pyx_mstate_global->__pyx_n_u_pandas, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 32, __pyx_L19_error) + __pyx_t_26 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pandas, 0, 0, __pyx_mstate_global->__pyx_kp_u_talib_pandas, -1); if (unlikely(!__pyx_t_26)) __PYX_ERR(2, 32, __pyx_L19_error) + __pyx_t_4 = __pyx_t_26; __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pandas, __pyx_t_4) < 0) __PYX_ERR(2, 32, __pyx_L19_error) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pandas, __pyx_t_4) < (0)) __PYX_ERR(2, 32, __pyx_L19_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_INPUT_ARRAYS_TYPES); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 33, __pyx_L19_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_pandas); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 33, __pyx_L19_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DataFrame); if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 33, __pyx_L19_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_26 = __Pyx_PyObject_Append(__pyx_t_4, __pyx_t_20); if (unlikely(__pyx_t_26 == ((int)-1))) __PYX_ERR(2, 33, __pyx_L19_error) + __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_pandas); if (unlikely(!__pyx_t_19)) __PYX_ERR(2, 33, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_19); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_DataFrame); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 33, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_27 = __Pyx_PyObject_Append(__pyx_t_4, __pyx_t_6); if (unlikely(__pyx_t_27 == ((int)-1))) __PYX_ERR(2, 33, __pyx_L19_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_ARRAY_TYPES); if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 34, __pyx_L19_error) - __Pyx_GOTREF(__pyx_t_20); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_ARRAY_TYPES); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 34, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_pandas); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 34, __pyx_L19_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Series); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 34, __pyx_L19_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Series); if (unlikely(!__pyx_t_19)) __PYX_ERR(2, 34, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_19); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_26 = __Pyx_PyObject_Append(__pyx_t_20, __pyx_t_7); if (unlikely(__pyx_t_26 == ((int)-1))) __PYX_ERR(2, 34, __pyx_L19_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_27 = __Pyx_PyObject_Append(__pyx_t_6, __pyx_t_19); if (unlikely(__pyx_t_27 == ((int)-1))) __PYX_ERR(2, 34, __pyx_L19_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_pandas); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 35, __pyx_L19_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DataFrame); if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 35, __pyx_L19_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PANDAS_DATAFRAME, __pyx_t_20) < 0) __PYX_ERR(2, 35, __pyx_L19_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_pandas); if (unlikely(!__pyx_t_19)) __PYX_ERR(2, 35, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_19); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_DataFrame); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 35, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PANDAS_DATAFRAME, __pyx_t_6) < (0)) __PYX_ERR(2, 35, __pyx_L19_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_pandas); if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 36, __pyx_L19_error) - __Pyx_GOTREF(__pyx_t_20); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_Series); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 36, __pyx_L19_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PANDAS_SERIES, __pyx_t_7) < 0) __PYX_ERR(2, 36, __pyx_L19_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_pandas); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 36, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_Series); if (unlikely(!__pyx_t_19)) __PYX_ERR(2, 36, __pyx_L19_error) + __Pyx_GOTREF(__pyx_t_19); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PANDAS_SERIES, __pyx_t_19) < (0)) __PYX_ERR(2, 36, __pyx_L19_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; } __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0; @@ -84504,58 +83950,58 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_23 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ImportError); + __pyx_t_23 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_ImportError)))); if (__pyx_t_23) { __Pyx_AddTraceback("talib._ta_lib", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_20, &__pyx_t_4) < 0) __PYX_ERR(2, 37, __pyx_L21_except_error) - __Pyx_XGOTREF(__pyx_t_7); - __Pyx_XGOTREF(__pyx_t_20); + if (__Pyx_GetException(&__pyx_t_19, &__pyx_t_6, &__pyx_t_4) < 0) __PYX_ERR(2, 37, __pyx_L21_except_error) + __Pyx_XGOTREF(__pyx_t_19); + __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_import_error, __pyx_t_20) < 0) __PYX_ERR(2, 37, __pyx_L21_except_error) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_import_error, __pyx_t_6) < (0)) __PYX_ERR(2, 37, __pyx_L21_except_error) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_27, &__pyx_t_28, &__pyx_t_29); - __Pyx_XGOTREF(__pyx_t_27); + __Pyx_ExceptionSave(&__pyx_t_26, &__pyx_t_28, &__pyx_t_29); + __Pyx_XGOTREF(__pyx_t_26); __Pyx_XGOTREF(__pyx_t_28); __Pyx_XGOTREF(__pyx_t_29); /*try:*/ { - __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_import_error); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 39, __pyx_L27_error) - __Pyx_GOTREF(__pyx_t_15); - __pyx_t_31 = PyObject_IsInstance(__pyx_t_15, __pyx_builtin_ModuleNotFoundError); if (unlikely(__pyx_t_31 == ((int)-1))) __PYX_ERR(2, 39, __pyx_L27_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_import_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 39, __pyx_L27_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_31 = __Pyx_PyExc_ModuleNotFoundError_Check(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_32 = (!__pyx_t_31); if (!__pyx_t_32) { } else { __pyx_t_30 = __pyx_t_32; goto __pyx_L36_bool_binop_done; } - __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_import_error); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 39, __pyx_L27_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_import_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 39, __pyx_L27_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 39, __pyx_L27_error) __Pyx_GOTREF(__pyx_t_15); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 39, __pyx_L27_error) - __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_32 = (__Pyx_PyUnicode_Equals(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_pandas, Py_NE)); if (unlikely((__pyx_t_32 < 0))) __PYX_ERR(2, 39, __pyx_L27_error) __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - __pyx_t_32 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_pandas, Py_NE)); if (unlikely((__pyx_t_32 < 0))) __PYX_ERR(2, 39, __pyx_L27_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_30 = __pyx_t_32; __pyx_L36_bool_binop_done:; if (unlikely(__pyx_t_30)) { - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_import_error); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 41, __pyx_L27_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_import_error); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 41, __pyx_L27_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_Raise(__pyx_t_15, 0, 0, 0); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __PYX_ERR(2, 41, __pyx_L27_error) } } - __Pyx_XDECREF(__pyx_t_27); __pyx_t_27 = 0; + __Pyx_XDECREF(__pyx_t_26); __pyx_t_26 = 0; __Pyx_XDECREF(__pyx_t_28); __pyx_t_28 = 0; __Pyx_XDECREF(__pyx_t_29); __pyx_t_29 = 0; goto __pyx_L34_try_end; @@ -84567,15 +84013,15 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_23 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_NameError); + __pyx_t_23 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_NameError)))); if (__pyx_t_23) { __Pyx_ErrRestore(0,0,0); goto __pyx_L28_exception_handled; @@ -84583,24 +84029,24 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); goto __pyx_L29_except_error; __pyx_L29_except_error:; - __Pyx_XGIVEREF(__pyx_t_27); + __Pyx_XGIVEREF(__pyx_t_26); __Pyx_XGIVEREF(__pyx_t_28); __Pyx_XGIVEREF(__pyx_t_29); - __Pyx_ExceptionReset(__pyx_t_27, __pyx_t_28, __pyx_t_29); + __Pyx_ExceptionReset(__pyx_t_26, __pyx_t_28, __pyx_t_29); goto __pyx_L21_except_error; __pyx_L28_exception_handled:; - __Pyx_XGIVEREF(__pyx_t_27); + __Pyx_XGIVEREF(__pyx_t_26); __Pyx_XGIVEREF(__pyx_t_28); __Pyx_XGIVEREF(__pyx_t_29); - __Pyx_ExceptionReset(__pyx_t_27, __pyx_t_28, __pyx_t_29); + __Pyx_ExceptionReset(__pyx_t_26, __pyx_t_28, __pyx_t_29); __pyx_L34_try_end:; } - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PANDAS_DATAFRAME, Py_None) < 0) __PYX_ERR(2, 46, __pyx_L21_except_error) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PANDAS_DATAFRAME, Py_None) < (0)) __PYX_ERR(2, 46, __pyx_L21_except_error) - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PANDAS_SERIES, Py_None) < 0) __PYX_ERR(2, 47, __pyx_L21_except_error) - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PANDAS_SERIES, Py_None) < (0)) __PYX_ERR(2, 47, __pyx_L21_except_error) + __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L20_exception_handled; } @@ -84629,48 +84075,49 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); __Pyx_XGOTREF(__pyx_t_25); /*try:*/ { - __pyx_t_4 = __Pyx_ImportDottedModuleRelFirst(__pyx_mstate_global->__pyx_n_u_polars, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 51, __pyx_L40_error) + __pyx_t_29 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_polars, 0, 0, __pyx_mstate_global->__pyx_kp_u_talib_polars, -1); if (unlikely(!__pyx_t_29)) __PYX_ERR(2, 51, __pyx_L40_error) + __pyx_t_4 = __pyx_t_29; __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_polars, __pyx_t_4) < 0) __PYX_ERR(2, 51, __pyx_L40_error) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_polars, __pyx_t_4) < (0)) __PYX_ERR(2, 51, __pyx_L40_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_INPUT_ARRAYS_TYPES); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 52, __pyx_L40_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_GetModuleGlobalName(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_polars); if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 52, __pyx_L40_error) - __Pyx_GOTREF(__pyx_t_20); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_DataFrame); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 52, __pyx_L40_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_26 = __Pyx_PyObject_Append(__pyx_t_4, __pyx_t_7); if (unlikely(__pyx_t_26 == ((int)-1))) __PYX_ERR(2, 52, __pyx_L40_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_polars); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 52, __pyx_L40_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DataFrame); if (unlikely(!__pyx_t_19)) __PYX_ERR(2, 52, __pyx_L40_error) + __Pyx_GOTREF(__pyx_t_19); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_27 = __Pyx_PyObject_Append(__pyx_t_4, __pyx_t_19); if (unlikely(__pyx_t_27 == ((int)-1))) __PYX_ERR(2, 52, __pyx_L40_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_ARRAY_TYPES); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 53, __pyx_L40_error) - __Pyx_GOTREF(__pyx_t_7); + __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_ARRAY_TYPES); if (unlikely(!__pyx_t_19)) __PYX_ERR(2, 53, __pyx_L40_error) + __Pyx_GOTREF(__pyx_t_19); __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_polars); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 53, __pyx_L40_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Series); if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 53, __pyx_L40_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Series); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 53, __pyx_L40_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_26 = __Pyx_PyObject_Append(__pyx_t_7, __pyx_t_20); if (unlikely(__pyx_t_26 == ((int)-1))) __PYX_ERR(2, 53, __pyx_L40_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __pyx_t_27 = __Pyx_PyObject_Append(__pyx_t_19, __pyx_t_6); if (unlikely(__pyx_t_27 == ((int)-1))) __PYX_ERR(2, 53, __pyx_L40_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_polars); if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 54, __pyx_L40_error) - __Pyx_GOTREF(__pyx_t_20); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_DataFrame); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 54, __pyx_L40_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME, __pyx_t_7) < 0) __PYX_ERR(2, 54, __pyx_L40_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_polars); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 54, __pyx_L40_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DataFrame); if (unlikely(!__pyx_t_19)) __PYX_ERR(2, 54, __pyx_L40_error) + __Pyx_GOTREF(__pyx_t_19); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME, __pyx_t_19) < (0)) __PYX_ERR(2, 54, __pyx_L40_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_polars); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 55, __pyx_L40_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_Series); if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 55, __pyx_L40_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_POLARS_SERIES, __pyx_t_20) < 0) __PYX_ERR(2, 55, __pyx_L40_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_polars); if (unlikely(!__pyx_t_19)) __PYX_ERR(2, 55, __pyx_L40_error) + __Pyx_GOTREF(__pyx_t_19); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_Series); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 55, __pyx_L40_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_POLARS_SERIES, __pyx_t_6) < (0)) __PYX_ERR(2, 55, __pyx_L40_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -84693,52 +84140,52 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_23 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ImportError); + __pyx_t_23 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_ImportError)))); if (__pyx_t_23) { __Pyx_AddTraceback("talib._ta_lib", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_20, &__pyx_t_7, &__pyx_t_4) < 0) __PYX_ERR(2, 56, __pyx_L42_except_error) - __Pyx_XGOTREF(__pyx_t_20); - __Pyx_XGOTREF(__pyx_t_7); + if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_19, &__pyx_t_4) < 0) __PYX_ERR(2, 56, __pyx_L42_except_error) + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_19); __Pyx_XGOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_import_error, __pyx_t_7) < 0) __PYX_ERR(2, 56, __pyx_L42_except_error) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_import_error, __pyx_t_19) < (0)) __PYX_ERR(2, 56, __pyx_L42_except_error) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_29, &__pyx_t_28, &__pyx_t_27); + __Pyx_ExceptionSave(&__pyx_t_29, &__pyx_t_28, &__pyx_t_26); __Pyx_XGOTREF(__pyx_t_29); __Pyx_XGOTREF(__pyx_t_28); - __Pyx_XGOTREF(__pyx_t_27); + __Pyx_XGOTREF(__pyx_t_26); /*try:*/ { - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_import_error); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 58, __pyx_L48_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_32 = PyObject_IsInstance(__pyx_t_2, __pyx_builtin_ModuleNotFoundError); if (unlikely(__pyx_t_32 == ((int)-1))) __PYX_ERR(2, 58, __pyx_L48_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_import_error); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 58, __pyx_L48_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_32 = __Pyx_PyExc_ModuleNotFoundError_Check(__pyx_t_15); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __pyx_t_31 = (!__pyx_t_32); if (!__pyx_t_31) { } else { __pyx_t_30 = __pyx_t_31; goto __pyx_L57_bool_binop_done; } - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_import_error); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 58, __pyx_L48_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 58, __pyx_L48_error) + __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_import_error); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 58, __pyx_L48_error) __Pyx_GOTREF(__pyx_t_15); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_31 = (__Pyx_PyUnicode_Equals(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_polars, Py_NE)); if (unlikely((__pyx_t_31 < 0))) __PYX_ERR(2, 58, __pyx_L48_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 58, __pyx_L48_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_31 = (__Pyx_PyUnicode_Equals(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_polars, Py_NE)); if (unlikely((__pyx_t_31 < 0))) __PYX_ERR(2, 58, __pyx_L48_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_30 = __pyx_t_31; __pyx_L57_bool_binop_done:; if (unlikely(__pyx_t_30)) { - __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_import_error); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 60, __pyx_L48_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_Raise(__pyx_t_15, 0, 0, 0); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_import_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 60, __pyx_L48_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(2, 60, __pyx_L48_error) } @@ -84746,7 +84193,7 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); } __Pyx_XDECREF(__pyx_t_29); __pyx_t_29 = 0; __Pyx_XDECREF(__pyx_t_28); __pyx_t_28 = 0; - __Pyx_XDECREF(__pyx_t_27); __pyx_t_27 = 0; + __Pyx_XDECREF(__pyx_t_26); __pyx_t_26 = 0; goto __pyx_L55_try_end; __pyx_L48_error:; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; @@ -84756,15 +84203,15 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_23 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_NameError); + __pyx_t_23 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_NameError)))); if (__pyx_t_23) { __Pyx_ErrRestore(0,0,0); goto __pyx_L49_exception_handled; @@ -84774,22 +84221,22 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); __pyx_L50_except_error:; __Pyx_XGIVEREF(__pyx_t_29); __Pyx_XGIVEREF(__pyx_t_28); - __Pyx_XGIVEREF(__pyx_t_27); - __Pyx_ExceptionReset(__pyx_t_29, __pyx_t_28, __pyx_t_27); + __Pyx_XGIVEREF(__pyx_t_26); + __Pyx_ExceptionReset(__pyx_t_29, __pyx_t_28, __pyx_t_26); goto __pyx_L42_except_error; __pyx_L49_exception_handled:; __Pyx_XGIVEREF(__pyx_t_29); __Pyx_XGIVEREF(__pyx_t_28); - __Pyx_XGIVEREF(__pyx_t_27); - __Pyx_ExceptionReset(__pyx_t_29, __pyx_t_28, __pyx_t_27); + __Pyx_XGIVEREF(__pyx_t_26); + __Pyx_ExceptionReset(__pyx_t_29, __pyx_t_28, __pyx_t_26); __pyx_L55_try_end:; } - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME, Py_None) < 0) __PYX_ERR(2, 65, __pyx_L42_except_error) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME, Py_None) < (0)) __PYX_ERR(2, 65, __pyx_L42_except_error) - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_POLARS_SERIES, Py_None) < 0) __PYX_ERR(2, 66, __pyx_L42_except_error) - __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_POLARS_SERIES, Py_None) < (0)) __PYX_ERR(2, 66, __pyx_L42_except_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L41_exception_handled; } @@ -84811,39 +84258,45 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_INPUT_ARRAYS_TYPES); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_7 = __Pyx_PySequence_Tuple(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 68, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = __Pyx_PySequence_Tuple(__pyx_t_4); if (unlikely(!__pyx_t_19)) __PYX_ERR(2, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_INPUT_ARRAYS_TYPES, __pyx_t_7) < 0) __PYX_ERR(2, 68, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_INPUT_ARRAYS_TYPES, __pyx_t_19) < (0)) __PYX_ERR(2, 68, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_ARRAY_TYPES); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 69, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 69, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_ARRAY_TYPES); if (unlikely(!__pyx_t_19)) __PYX_ERR(2, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_t_19); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 69, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ARRAY_TYPES, __pyx_t_4) < 0) __PYX_ERR(2, 69, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ARRAY_TYPES, __pyx_t_4) < (0)) __PYX_ERR(2, 69, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_sys); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 72, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_version); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 72, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_version); if (unlikely(!__pyx_t_19)) __PYX_ERR(2, 72, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyObject_RichCompare(__pyx_t_7, __pyx_mstate_global->__pyx_kp_u_3, Py_GE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 72, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_4 = PyObject_RichCompare(__pyx_t_19, __pyx_mstate_global->__pyx_kp_u_3, Py_GE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 72, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_30 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_30 < 0))) __PYX_ERR(2, 72, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_30) { __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_341str2bytes, 0, __pyx_mstate_global->__pyx_n_u_str2bytes, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[172])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 74, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_str2bytes, __pyx_t_4) < 0) __PYX_ERR(2, 74, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_str2bytes, __pyx_t_4) < (0)) __PYX_ERR(2, 74, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_343bytes2str, 0, __pyx_mstate_global->__pyx_n_u_bytes2str, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[173])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_bytes2str, __pyx_t_4) < 0) __PYX_ERR(2, 77, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_bytes2str, __pyx_t_4) < (0)) __PYX_ERR(2, 77, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L61; @@ -84852,417 +84305,492 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); /*else*/ { __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_345str2bytes, 0, __pyx_mstate_global->__pyx_n_u_str2bytes, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[174])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 82, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_str2bytes, __pyx_t_4) < 0) __PYX_ERR(2, 82, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_str2bytes, __pyx_t_4) < (0)) __PYX_ERR(2, 82, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_347bytes2str, 0, __pyx_mstate_global->__pyx_n_u_bytes2str, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[175])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 85, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_bytes2str, __pyx_t_4) < 0) __PYX_ERR(2, 85, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_bytes2str, __pyx_t_4) < (0)) __PYX_ERR(2, 85, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_L61:; __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_mstate_global->__pyx_tuple[8]); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 88, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_7 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 88, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_20 = __Pyx_Py3MetaclassPrepare(__pyx_t_7, __pyx_t_4, __pyx_mstate_global->__pyx_n_u_Function, __pyx_mstate_global->__pyx_n_u_Function, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_kp_u_This_is_a_pythonic_wrapper_arou); if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 88, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_19 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_19)) __PYX_ERR(2, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __pyx_t_6 = __Pyx_Py3MetaclassPrepare(__pyx_t_19, __pyx_t_4, __pyx_mstate_global->__pyx_n_u_Function, __pyx_mstate_global->__pyx_n_u_Function, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_kp_u_This_is_a_pythonic_wrapper_arou); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4 != __pyx_mstate_global->__pyx_tuple[8]) { - if (unlikely((PyDict_SetItemString(__pyx_t_20, "__orig_bases__", __pyx_mstate_global->__pyx_tuple[8]) < 0))) __PYX_ERR(2, 88, __pyx_L1_error) + if (unlikely((PyDict_SetItemString(__pyx_t_6, "__orig_bases__", __pyx_mstate_global->__pyx_tuple[8]) < 0))) __PYX_ERR(2, 88, __pyx_L1_error) } - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_1__init__, 0, __pyx_mstate_global->__pyx_n_u_Function___init, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[176])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 117, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_init, __pyx_t_15) < 0) __PYX_ERR(2, 117, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - - __pyx_t_2 = NULL; - __Pyx_INCREF(__pyx_builtin_property); - __pyx_t_6 = __pyx_builtin_property; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_3__local, 0, __pyx_mstate_global->__pyx_n_u_Function___local, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[177])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 130, __pyx_L1_error) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_1__init__, 0, __pyx_mstate_global->__pyx_n_u_Function___init, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[176])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 117, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = 1; + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_init, __pyx_t_3) < (0)) __PYX_ERR(2, 117, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_15 = NULL; + __pyx_t_8 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_3__local, 0, __pyx_mstate_global->__pyx_n_u_Function___local, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[177])); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 130, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_8); + #endif + __pyx_t_7 = 1; { - PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3}; - __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 130, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); + PyObject *__pyx_callargs[2] = {__pyx_t_15, __pyx_t_8}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_property, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 130, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); } - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_Function__local, __pyx_t_15) < 0) __PYX_ERR(2, 130, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_Function__local, __pyx_t_3) < (0)) __PYX_ERR(2, 130, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = NULL; - __Pyx_INCREF(__pyx_builtin_property); - __pyx_t_3 = __pyx_builtin_property; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_5info, 0, __pyx_mstate_global->__pyx_n_u_Function_info, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[178])); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 172, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_8 = 1; + __pyx_t_8 = NULL; + __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_5info, 0, __pyx_mstate_global->__pyx_n_u_Function_info, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[178])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_15); + #endif + __pyx_t_7 = 1; { - PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_2}; - __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 172, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_15}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_property, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); } - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_info, __pyx_t_15) < 0) __PYX_ERR(2, 172, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_info, __pyx_t_3) < (0)) __PYX_ERR(2, 172, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = NULL; - __Pyx_INCREF(__pyx_builtin_property); - __pyx_t_2 = __pyx_builtin_property; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_7function_flags, 0, __pyx_mstate_global->__pyx_n_u_Function_function_flags, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[179])); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 179, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = 1; + __pyx_t_15 = NULL; + __pyx_t_8 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_7function_flags, 0, __pyx_mstate_global->__pyx_n_u_Function_function_flags, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[179])); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_8); + #endif + __pyx_t_7 = 1; { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_6}; - __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 179, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); + PyObject *__pyx_callargs[2] = {__pyx_t_15, __pyx_t_8}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_property, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); } - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_function_flags, __pyx_t_15) < 0) __PYX_ERR(2, 179, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_function_flags, __pyx_t_3) < (0)) __PYX_ERR(2, 179, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = NULL; - __Pyx_INCREF(__pyx_builtin_property); - __pyx_t_6 = __pyx_builtin_property; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_9output_flags, 0, __pyx_mstate_global->__pyx_n_u_Function_output_flags, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[180])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 186, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = 1; + __pyx_t_8 = NULL; + __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_9output_flags, 0, __pyx_mstate_global->__pyx_n_u_Function_output_flags, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[180])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_15); + #endif + __pyx_t_7 = 1; { - PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3}; - __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 186, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_15}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_property, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); } - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_output_flags, __pyx_t_15) < 0) __PYX_ERR(2, 186, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_output_flags, __pyx_t_3) < (0)) __PYX_ERR(2, 186, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_11get_input_names, 0, __pyx_mstate_global->__pyx_n_u_Function_get_input_names, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[181])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 193, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_get_input_names, __pyx_t_15) < 0) __PYX_ERR(2, 193, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_11get_input_names, 0, __pyx_mstate_global->__pyx_n_u_Function_get_input_names, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[181])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_get_input_names, __pyx_t_3) < (0)) __PYX_ERR(2, 193, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_13set_input_names, 0, __pyx_mstate_global->__pyx_n_u_Function_set_input_names, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[182])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 204, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_set_input_names, __pyx_t_15) < 0) __PYX_ERR(2, 204, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_13set_input_names, 0, __pyx_mstate_global->__pyx_n_u_Function_set_input_names, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[182])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_set_input_names, __pyx_t_3) < (0)) __PYX_ERR(2, 204, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = NULL; - __Pyx_INCREF(__pyx_builtin_property); - __pyx_t_3 = __pyx_builtin_property; - __pyx_t_2 = PyObject_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_get_input_names); + __pyx_t_15 = NULL; + __pyx_t_8 = PyObject_GetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_get_input_names); + if (unlikely(!__pyx_t_8)) { + PyErr_Clear(); + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_get_input_names); + } + if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_2 = PyObject_GetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_set_input_names); if (unlikely(!__pyx_t_2)) { PyErr_Clear(); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_get_input_names); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_set_input_names); } if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 214, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_16 = PyObject_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_set_input_names); - if (unlikely(!__pyx_t_16)) { - PyErr_Clear(); - __Pyx_GetModuleGlobalName(__pyx_t_16, __pyx_mstate_global->__pyx_n_u_set_input_names); - } - if (unlikely(!__pyx_t_16)) __PYX_ERR(2, 214, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_16); - __pyx_t_8 = 1; + __pyx_t_7 = 1; { - PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_2, __pyx_t_16}; - __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + PyObject *__pyx_callargs[3] = {__pyx_t_15, __pyx_t_8, __pyx_t_2}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_property, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 214, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); } - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_input_names, __pyx_t_15) < 0) __PYX_ERR(2, 214, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_input_names, __pyx_t_3) < (0)) __PYX_ERR(2, 214, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_15get_input_arrays, 0, __pyx_mstate_global->__pyx_n_u_Function_get_input_arrays, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[183])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 216, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_get_input_arrays, __pyx_t_15) < 0) __PYX_ERR(2, 216, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_15get_input_arrays, 0, __pyx_mstate_global->__pyx_n_u_Function_get_input_arrays, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[183])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_get_input_arrays, __pyx_t_3) < (0)) __PYX_ERR(2, 216, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_17set_input_arrays, 0, __pyx_mstate_global->__pyx_n_u_Function_set_input_arrays, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[184])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 227, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_set_input_arrays, __pyx_t_15) < 0) __PYX_ERR(2, 227, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_17set_input_arrays, 0, __pyx_mstate_global->__pyx_n_u_Function_set_input_arrays, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[184])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 227, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_set_input_arrays, __pyx_t_3) < (0)) __PYX_ERR(2, 227, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = NULL; - __Pyx_INCREF(__pyx_builtin_property); - __pyx_t_16 = __pyx_builtin_property; - __pyx_t_2 = PyObject_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_get_input_arrays); - if (unlikely(!__pyx_t_2)) { + __pyx_t_2 = NULL; + __pyx_t_8 = PyObject_GetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_get_input_arrays); + if (unlikely(!__pyx_t_8)) { PyErr_Clear(); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_get_input_arrays); + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_get_input_arrays); } - if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 274, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = PyObject_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_set_input_arrays); - if (unlikely(!__pyx_t_6)) { + if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_15 = PyObject_GetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_set_input_arrays); + if (unlikely(!__pyx_t_15)) { PyErr_Clear(); - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_set_input_arrays); + __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_set_input_arrays); } - if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 274, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = 1; + if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_7 = 1; { - PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_2, __pyx_t_6}; - __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_16, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 274, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_8, __pyx_t_15}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_property, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); } - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_input_arrays, __pyx_t_15) < 0) __PYX_ERR(2, 274, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_input_arrays, __pyx_t_3) < (0)) __PYX_ERR(2, 274, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_19get_parameters, 0, __pyx_mstate_global->__pyx_n_u_Function_get_parameters, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[185])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 276, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_get_parameters, __pyx_t_15) < 0) __PYX_ERR(2, 276, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_19get_parameters, 0, __pyx_mstate_global->__pyx_n_u_Function_get_parameters, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[185])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_get_parameters, __pyx_t_3) < (0)) __PYX_ERR(2, 276, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_21set_parameters, 0, __pyx_mstate_global->__pyx_n_u_Function_set_parameters, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[186])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 286, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_15, __pyx_mstate_global->__pyx_tuple[9]); - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_set_parameters, __pyx_t_15) < 0) __PYX_ERR(2, 286, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_21set_parameters, 0, __pyx_mstate_global->__pyx_n_u_Function_set_parameters, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[186])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_mstate_global->__pyx_tuple[9]); + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_set_parameters, __pyx_t_3) < (0)) __PYX_ERR(2, 286, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_16 = NULL; - __Pyx_INCREF(__pyx_builtin_property); - __pyx_t_6 = __pyx_builtin_property; - __pyx_t_2 = PyObject_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_get_parameters); + __pyx_t_15 = NULL; + __pyx_t_8 = PyObject_GetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_get_parameters); + if (unlikely(!__pyx_t_8)) { + PyErr_Clear(); + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_get_parameters); + } + if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_2 = PyObject_GetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_set_parameters); if (unlikely(!__pyx_t_2)) { PyErr_Clear(); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_get_parameters); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_set_parameters); } if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 299, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyObject_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_set_parameters); - if (unlikely(!__pyx_t_3)) { - PyErr_Clear(); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_set_parameters); - } - if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 299, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = 1; + __pyx_t_7 = 1; { - PyObject *__pyx_callargs[3] = {__pyx_t_16, __pyx_t_2, __pyx_t_3}; - __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; + PyObject *__pyx_callargs[3] = {__pyx_t_15, __pyx_t_8, __pyx_t_2}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_property, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 299, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); } - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_parameters, __pyx_t_15) < 0) __PYX_ERR(2, 299, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_parameters, __pyx_t_3) < (0)) __PYX_ERR(2, 299, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_23set_function_args, 0, __pyx_mstate_global->__pyx_n_u_Function_set_function_args, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[187])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 301, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_set_function_args, __pyx_t_15) < 0) __PYX_ERR(2, 301, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_23set_function_args, 0, __pyx_mstate_global->__pyx_n_u_Function_set_function_args, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[187])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_set_function_args, __pyx_t_3) < (0)) __PYX_ERR(2, 301, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = NULL; - __Pyx_INCREF(__pyx_builtin_property); - __pyx_t_3 = __pyx_builtin_property; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_25lookback, 0, __pyx_mstate_global->__pyx_n_u_Function_lookback, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[188])); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 336, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_8 = 1; + __pyx_t_2 = NULL; + __pyx_t_8 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_25lookback, 0, __pyx_mstate_global->__pyx_n_u_Function_lookback, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[188])); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_8); + #endif + __pyx_t_7 = 1; { - PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_2}; - __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 336, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_8}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_property, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); } - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_lookback, __pyx_t_15) < 0) __PYX_ERR(2, 336, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_lookback, __pyx_t_3) < (0)) __PYX_ERR(2, 336, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = NULL; - __Pyx_INCREF(__pyx_builtin_property); - __pyx_t_2 = __pyx_builtin_property; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_27output_names, 0, __pyx_mstate_global->__pyx_n_u_Function_output_names, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[189])); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 357, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = 1; + __pyx_t_8 = NULL; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_27output_names, 0, __pyx_mstate_global->__pyx_n_u_Function_output_names, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[189])); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __pyx_t_7 = 1; { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_6}; - __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_2}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_property, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 357, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); } - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_output_names, __pyx_t_15) < 0) __PYX_ERR(2, 357, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_output_names, __pyx_t_3) < (0)) __PYX_ERR(2, 357, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_2 = NULL; - __Pyx_INCREF(__pyx_builtin_property); - __pyx_t_6 = __pyx_builtin_property; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_29outputs, 0, __pyx_mstate_global->__pyx_n_u_Function_outputs, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[190])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 367, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = 1; + __pyx_t_8 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_29outputs, 0, __pyx_mstate_global->__pyx_n_u_Function_outputs, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[190])); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_8); + #endif + __pyx_t_7 = 1; { - PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3}; - __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_8}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_property, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 367, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); } - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_outputs, __pyx_t_15) < 0) __PYX_ERR(2, 367, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_outputs, __pyx_t_3) < (0)) __PYX_ERR(2, 367, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_31run, 0, __pyx_mstate_global->__pyx_n_u_Function_run, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[191])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 399, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_15, __pyx_mstate_global->__pyx_tuple[9]); - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_run, __pyx_t_15) < 0) __PYX_ERR(2, 399, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_31run, 0, __pyx_mstate_global->__pyx_n_u_Function_run, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[191])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_mstate_global->__pyx_tuple[9]); + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_run, __pyx_t_3) < (0)) __PYX_ERR(2, 399, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_33__call__, 0, __pyx_mstate_global->__pyx_n_u_Function___call, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[192])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 411, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_call, __pyx_t_15) < 0) __PYX_ERR(2, 411, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_33__call__, 0, __pyx_mstate_global->__pyx_n_u_Function___call, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[192])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_call, __pyx_t_3) < (0)) __PYX_ERR(2, 411, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_35__input_price_series_names, 0, __pyx_mstate_global->__pyx_n_u_Function___input_price_series_na, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[193])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 477, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_Function__input_price_series_na, __pyx_t_15) < 0) __PYX_ERR(2, 477, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_35__input_price_series_names, 0, __pyx_mstate_global->__pyx_n_u_Function___input_price_series_na, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[193])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 477, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_Function__input_price_series_na, __pyx_t_3) < (0)) __PYX_ERR(2, 477, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_37__call_function, 0, __pyx_mstate_global->__pyx_n_u_Function___call_function, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[194])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 489, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_Function__call_function, __pyx_t_15) < 0) __PYX_ERR(2, 489, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_37__call_function, 0, __pyx_mstate_global->__pyx_n_u_Function___call_function, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[194])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_Function__call_function, __pyx_t_3) < (0)) __PYX_ERR(2, 489, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_39__check_opt_input_value, 0, __pyx_mstate_global->__pyx_n_u_Function___check_opt_input_value, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[195])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 520, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_Function__check_opt_input_value, __pyx_t_15) < 0) __PYX_ERR(2, 520, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_39__check_opt_input_value, 0, __pyx_mstate_global->__pyx_n_u_Function___check_opt_input_value, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[195])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 520, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_Function__check_opt_input_value, __pyx_t_3) < (0)) __PYX_ERR(2, 520, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_41__get_opt_input_value, 0, __pyx_mstate_global->__pyx_n_u_Function___get_opt_input_value, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[196])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 535, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_Function__get_opt_input_value, __pyx_t_15) < 0) __PYX_ERR(2, 535, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_41__get_opt_input_value, 0, __pyx_mstate_global->__pyx_n_u_Function___get_opt_input_value, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[196])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 535, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_Function__get_opt_input_value, __pyx_t_3) < (0)) __PYX_ERR(2, 535, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_43__repr__, 0, __pyx_mstate_global->__pyx_n_u_Function___repr, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[197])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 545, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_repr, __pyx_t_15) < 0) __PYX_ERR(2, 545, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_43__repr__, 0, __pyx_mstate_global->__pyx_n_u_Function___repr, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[197])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_repr, __pyx_t_3) < (0)) __PYX_ERR(2, 545, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_45__unicode__, 0, __pyx_mstate_global->__pyx_n_u_Function___unicode, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[198])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 548, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_unicode, __pyx_t_15) < 0) __PYX_ERR(2, 548, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_45__unicode__, 0, __pyx_mstate_global->__pyx_n_u_Function___unicode, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[198])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 548, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_unicode, __pyx_t_3) < (0)) __PYX_ERR(2, 548, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_47__str__, 0, __pyx_mstate_global->__pyx_n_u_Function___str, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[199])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 551, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_str, __pyx_t_15) < 0) __PYX_ERR(2, 551, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_47__str__, 0, __pyx_mstate_global->__pyx_n_u_Function___str, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[199])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 551, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_str, __pyx_t_3) < (0)) __PYX_ERR(2, 551, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_15 = __Pyx_Py3ClassCreate(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_Function, __pyx_t_4, __pyx_t_20, NULL, 0, 1); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 88, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_Function, __pyx_t_15) < 0) __PYX_ERR(2, 88, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_3 = __Pyx_Py3ClassCreate(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_Function, __pyx_t_4, __pyx_t_6, NULL, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_Function, __pyx_t_3) < (0)) __PYX_ERR(2, 88, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_349_ta_getGroupTable, 0, __pyx_mstate_global->__pyx_n_u_ta_getGroupTable, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[200])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 565, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_getGroupTable, __pyx_t_4) < 0) __PYX_ERR(2, 565, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_getGroupTable, __pyx_t_4) < (0)) __PYX_ERR(2, 565, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_351_ta_getFuncTable, 0, __pyx_mstate_global->__pyx_n_u_ta_getFuncTable, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[201])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 577, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_getFuncTable, __pyx_t_4) < 0) __PYX_ERR(2, 577, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_getFuncTable, __pyx_t_4) < (0)) __PYX_ERR(2, 577, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_353__get_flags, 0, __pyx_mstate_global->__pyx_n_u_get_flags, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[202])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 589, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_get_flags, __pyx_t_4) < 0) __PYX_ERR(2, 589, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_get_flags, __pyx_t_4) < (0)) __PYX_ERR(2, 589, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 615, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_16777216, __pyx_mstate_global->__pyx_kp_u_Output_scale_same_as_input) < 0) __PYX_ERR(2, 615, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_67108864, __pyx_mstate_global->__pyx_kp_u_Output_is_over_volume) < 0) __PYX_ERR(2, 615, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_134217728, __pyx_mstate_global->__pyx_kp_u_Function_has_an_unstable_period) < 0) __PYX_ERR(2, 615, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_268435456, __pyx_mstate_global->__pyx_kp_u_Output_is_a_candlestick) < 0) __PYX_ERR(2, 615, __pyx_L1_error) - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TA_FUNC_FLAGS, __pyx_t_4) < 0) __PYX_ERR(2, 614, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_16777216, __pyx_mstate_global->__pyx_kp_u_Output_scale_same_as_input) < (0)) __PYX_ERR(2, 615, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_67108864, __pyx_mstate_global->__pyx_kp_u_Output_is_over_volume) < (0)) __PYX_ERR(2, 615, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_134217728, __pyx_mstate_global->__pyx_kp_u_Function_has_an_unstable_period) < (0)) __PYX_ERR(2, 615, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_268435456, __pyx_mstate_global->__pyx_kp_u_Output_is_a_candlestick) < (0)) __PYX_ERR(2, 615, __pyx_L1_error) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TA_FUNC_FLAGS, __pyx_t_4) < (0)) __PYX_ERR(2, 614, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 623, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_1, __pyx_mstate_global->__pyx_n_u_open) < 0) __PYX_ERR(2, 623, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_2, __pyx_mstate_global->__pyx_n_u_high) < 0) __PYX_ERR(2, 623, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_4, __pyx_mstate_global->__pyx_n_u_low) < 0) __PYX_ERR(2, 623, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_8, __pyx_mstate_global->__pyx_n_u_close) < 0) __PYX_ERR(2, 623, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_16, __pyx_mstate_global->__pyx_n_u_volume) < 0) __PYX_ERR(2, 623, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_32, __pyx_mstate_global->__pyx_n_u_openInterest) < 0) __PYX_ERR(2, 623, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_64, __pyx_mstate_global->__pyx_n_u_timeStamp) < 0) __PYX_ERR(2, 623, __pyx_L1_error) - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TA_INPUT_FLAGS, __pyx_t_4) < 0) __PYX_ERR(2, 622, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_1, __pyx_mstate_global->__pyx_n_u_open) < (0)) __PYX_ERR(2, 623, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_2, __pyx_mstate_global->__pyx_n_u_high) < (0)) __PYX_ERR(2, 623, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_4, __pyx_mstate_global->__pyx_n_u_low) < (0)) __PYX_ERR(2, 623, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_8, __pyx_mstate_global->__pyx_n_u_close) < (0)) __PYX_ERR(2, 623, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_16, __pyx_mstate_global->__pyx_n_u_volume) < (0)) __PYX_ERR(2, 623, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_32, __pyx_mstate_global->__pyx_n_u_openInterest) < (0)) __PYX_ERR(2, 623, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_64, __pyx_mstate_global->__pyx_n_u_timeStamp) < (0)) __PYX_ERR(2, 623, __pyx_L1_error) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TA_INPUT_FLAGS, __pyx_t_4) < (0)) __PYX_ERR(2, 622, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyDict_NewPresized(13); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 633, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_1, __pyx_mstate_global->__pyx_n_u_Line) < 0) __PYX_ERR(2, 633, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_2, __pyx_mstate_global->__pyx_kp_u_Dotted_Line) < 0) __PYX_ERR(2, 633, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_4, __pyx_mstate_global->__pyx_kp_u_Dashed_Line) < 0) __PYX_ERR(2, 633, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_8, __pyx_mstate_global->__pyx_n_u_Dot) < 0) __PYX_ERR(2, 633, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_16, __pyx_mstate_global->__pyx_n_u_Histogram) < 0) __PYX_ERR(2, 633, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_32, __pyx_mstate_global->__pyx_kp_u_Pattern_Bool) < 0) __PYX_ERR(2, 633, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_64, __pyx_mstate_global->__pyx_kp_u_Bull_Bear_Pattern_Bearish_0_Neut) < 0) __PYX_ERR(2, 633, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_128, __pyx_mstate_global->__pyx_kp_u_Strength_Pattern_200_100_Bearish) < 0) __PYX_ERR(2, 633, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_256, __pyx_mstate_global->__pyx_kp_u_Output_can_be_positive) < 0) __PYX_ERR(2, 633, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_512, __pyx_mstate_global->__pyx_kp_u_Output_can_be_negative) < 0) __PYX_ERR(2, 633, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_1024, __pyx_mstate_global->__pyx_kp_u_Output_can_be_zero) < 0) __PYX_ERR(2, 633, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_2048, __pyx_mstate_global->__pyx_kp_u_Values_represent_an_upper_limit) < 0) __PYX_ERR(2, 633, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_4096, __pyx_mstate_global->__pyx_kp_u_Values_represent_a_lower_limit) < 0) __PYX_ERR(2, 633, __pyx_L1_error) - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TA_OUTPUT_FLAGS, __pyx_t_4) < 0) __PYX_ERR(2, 632, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_1, __pyx_mstate_global->__pyx_n_u_Line) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_2, __pyx_mstate_global->__pyx_kp_u_Dotted_Line) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_4, __pyx_mstate_global->__pyx_kp_u_Dashed_Line) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_8, __pyx_mstate_global->__pyx_n_u_Dot) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_16, __pyx_mstate_global->__pyx_n_u_Histogram) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_32, __pyx_mstate_global->__pyx_kp_u_Pattern_Bool) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_64, __pyx_mstate_global->__pyx_kp_u_Bull_Bear_Pattern_Bearish_0_Neut) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_128, __pyx_mstate_global->__pyx_kp_u_Strength_Pattern_200_100_Bearish) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_256, __pyx_mstate_global->__pyx_kp_u_Output_can_be_positive) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_512, __pyx_mstate_global->__pyx_kp_u_Output_can_be_negative) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_1024, __pyx_mstate_global->__pyx_kp_u_Output_can_be_zero) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_2048, __pyx_mstate_global->__pyx_kp_u_Values_represent_an_upper_limit) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_4096, __pyx_mstate_global->__pyx_kp_u_Values_represent_a_lower_limit) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TA_OUTPUT_FLAGS, __pyx_t_4) < (0)) __PYX_ERR(2, 632, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_355_ta_getFuncInfo, 0, __pyx_mstate_global->__pyx_n_u_ta_getFuncInfo, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[203])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 648, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_getFuncInfo, __pyx_t_4) < 0) __PYX_ERR(2, 648, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_getFuncInfo, __pyx_t_4) < (0)) __PYX_ERR(2, 648, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_357_ta_getInputParameterInfo, 0, __pyx_mstate_global->__pyx_n_u_ta_getInputParameterInfo, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[204])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 667, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_getInputParameterInfo, __pyx_t_4) < 0) __PYX_ERR(2, 667, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_getInputParameterInfo, __pyx_t_4) < (0)) __PYX_ERR(2, 667, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_359_ta_getOptInputParameterInfo, 0, __pyx_mstate_global->__pyx_n_u_ta_getOptInputParameterInfo, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[205])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 688, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_getOptInputParameterInfo, __pyx_t_4) < 0) __PYX_ERR(2, 688, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_getOptInputParameterInfo, __pyx_t_4) < (0)) __PYX_ERR(2, 688, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_361_ta_getOutputParameterInfo, 0, __pyx_mstate_global->__pyx_n_u_ta_getOutputParameterInfo, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[206])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 712, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_361_ta_getOutputParameterInfo, 0, __pyx_mstate_global->__pyx_n_u_ta_getOutputParameterInfo, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[206])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 710, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_getOutputParameterInfo, __pyx_t_4) < 0) __PYX_ERR(2, 712, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_getOutputParameterInfo, __pyx_t_4) < (0)) __PYX_ERR(2, 710, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_363_get_defaults_and_docs, 0, __pyx_mstate_global->__pyx_n_u_get_defaults_and_docs, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[207])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 732, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_363_get_defaults_and_docs, 0, __pyx_mstate_global->__pyx_n_u_get_defaults_and_docs, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[207])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 730, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_get_defaults_and_docs, __pyx_t_4) < 0) __PYX_ERR(2, 732, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_get_defaults_and_docs, __pyx_t_4) < (0)) __PYX_ERR(2, 730, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_23 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_23 == ((int)-1))) __PYX_ERR(5, 7, __pyx_L1_error) @@ -85270,1570 +84798,2053 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 11, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_7 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_365stream_ACCBANDS, 0, __pyx_mstate_global->__pyx_n_u_stream_ACCBANDS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[208])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_7); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ACCBANDS, __pyx_t_4) < 0) __PYX_ERR(5, 9, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_19); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ACCBANDS, __pyx_t_4) < (0)) __PYX_ERR(5, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_367stream_ACOS, 0, __pyx_mstate_global->__pyx_n_u_stream_ACOS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[209])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 50, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ACOS, __pyx_t_4) < 0) __PYX_ERR(5, 50, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ACOS, __pyx_t_4) < (0)) __PYX_ERR(5, 50, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_369stream_AD, 0, __pyx_mstate_global->__pyx_n_u_stream_AD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[210])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_AD, __pyx_t_4) < 0) __PYX_ERR(5, 77, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_AD, __pyx_t_4) < (0)) __PYX_ERR(5, 77, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_371stream_ADD, 0, __pyx_mstate_global->__pyx_n_u_stream_ADD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[211])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 113, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ADD, __pyx_t_4) < 0) __PYX_ERR(5, 113, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ADD, __pyx_t_4) < (0)) __PYX_ERR(5, 113, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 146, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 146, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_20 = PyTuple_Pack(2, __pyx_t_4, __pyx_t_7); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 144, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_6 = PyTuple_Pack(2, __pyx_t_4, __pyx_t_19); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_373stream_ADOSC, 0, __pyx_mstate_global->__pyx_n_u_stream_ADOSC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[212])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 144, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_20); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ADOSC, __pyx_t_7) < 0) __PYX_ERR(5, 144, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_373stream_ADOSC, 0, __pyx_mstate_global->__pyx_n_u_stream_ADOSC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[212])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ADOSC, __pyx_t_19) < (0)) __PYX_ERR(5, 144, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 185, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 185, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_20 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 183, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_375stream_ADX, 0, __pyx_mstate_global->__pyx_n_u_stream_ADX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[213])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 183, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_20); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ADX, __pyx_t_7) < 0) __PYX_ERR(5, 183, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_6 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 183, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_375stream_ADX, 0, __pyx_mstate_global->__pyx_n_u_stream_ADX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[213])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 183, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ADX, __pyx_t_19) < (0)) __PYX_ERR(5, 183, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_20 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 218, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_377stream_ADXR, 0, __pyx_mstate_global->__pyx_n_u_stream_ADXR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[214])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 218, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_20); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ADXR, __pyx_t_7) < 0) __PYX_ERR(5, 218, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_6 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_377stream_ADXR, 0, __pyx_mstate_global->__pyx_n_u_stream_ADXR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[214])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ADXR, __pyx_t_19) < (0)) __PYX_ERR(5, 218, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 255, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 255, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_15 = PyTuple_Pack(3, __pyx_t_7, __pyx_t_20, __pyx_t_4); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 253, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __pyx_t_3 = PyTuple_Pack(3, __pyx_t_19, __pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 253, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_379stream_APO, 0, __pyx_mstate_global->__pyx_n_u_stream_APO, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[215])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 253, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_APO, __pyx_t_4) < 0) __PYX_ERR(5, 253, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_APO, __pyx_t_4) < (0)) __PYX_ERR(5, 253, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 286, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_15 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 284, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); + __pyx_t_3 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_381stream_AROON, 0, __pyx_mstate_global->__pyx_n_u_stream_AROON, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[216])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 284, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_AROON, __pyx_t_4) < 0) __PYX_ERR(5, 284, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_AROON, __pyx_t_4) < (0)) __PYX_ERR(5, 284, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 321, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_15 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 319, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); + __pyx_t_3 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 319, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_383stream_AROONOSC, 0, __pyx_mstate_global->__pyx_n_u_stream_AROONOSC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[217])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 319, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_AROONOSC, __pyx_t_4) < 0) __PYX_ERR(5, 319, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_AROONOSC, __pyx_t_4) < (0)) __PYX_ERR(5, 319, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_385stream_ASIN, 0, __pyx_mstate_global->__pyx_n_u_stream_ASIN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[218])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ASIN, __pyx_t_4) < 0) __PYX_ERR(5, 351, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ASIN, __pyx_t_4) < (0)) __PYX_ERR(5, 351, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_387stream_ATAN, 0, __pyx_mstate_global->__pyx_n_u_stream_ATAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[219])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 378, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ATAN, __pyx_t_4) < 0) __PYX_ERR(5, 378, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ATAN, __pyx_t_4) < (0)) __PYX_ERR(5, 378, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 407, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_15 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 405, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); + __pyx_t_3 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_389stream_ATR, 0, __pyx_mstate_global->__pyx_n_u_stream_ATR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[220])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 405, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ATR, __pyx_t_4) < 0) __PYX_ERR(5, 405, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ATR, __pyx_t_4) < (0)) __PYX_ERR(5, 405, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_391stream_AVGPRICE, 0, __pyx_mstate_global->__pyx_n_u_stream_AVGPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[221])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 440, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_AVGPRICE, __pyx_t_4) < 0) __PYX_ERR(5, 440, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_AVGPRICE, __pyx_t_4) < (0)) __PYX_ERR(5, 440, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 478, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_15 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 476, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); + __pyx_t_3 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_393stream_AVGDEV, 0, __pyx_mstate_global->__pyx_n_u_stream_AVGDEV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[222])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 476, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_AVGDEV, __pyx_t_4) < 0) __PYX_ERR(5, 476, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_AVGDEV, __pyx_t_4) < (0)) __PYX_ERR(5, 476, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 507, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_15 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 507, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __pyx_t_20 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 507, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __pyx_t_7 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 507, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - - __pyx_t_6 = PyTuple_Pack(4, __pyx_t_4, __pyx_t_15, __pyx_t_20, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 505, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 507, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 507, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 507, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + + __pyx_t_8 = PyTuple_Pack(4, __pyx_t_4, __pyx_t_3, __pyx_t_6, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 505, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_395stream_BBANDS, 0, __pyx_mstate_global->__pyx_n_u_stream_BBANDS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[223])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 505, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_BBANDS, __pyx_t_7) < 0) __PYX_ERR(5, 505, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_395stream_BBANDS, 0, __pyx_mstate_global->__pyx_n_u_stream_BBANDS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[223])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 505, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_BBANDS, __pyx_t_19) < (0)) __PYX_ERR(5, 505, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 545, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 543, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_397stream_BETA, 0, __pyx_mstate_global->__pyx_n_u_stream_BETA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[224])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 543, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_BETA, __pyx_t_7) < 0) __PYX_ERR(5, 543, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 543, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_397stream_BETA, 0, __pyx_mstate_global->__pyx_n_u_stream_BETA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[224])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 543, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_BETA, __pyx_t_19) < (0)) __PYX_ERR(5, 543, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_399stream_BOP, 0, __pyx_mstate_global->__pyx_n_u_stream_BOP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[225])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 576, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_BOP, __pyx_t_7) < 0) __PYX_ERR(5, 576, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_399stream_BOP, 0, __pyx_mstate_global->__pyx_n_u_stream_BOP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[225])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 576, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_BOP, __pyx_t_19) < (0)) __PYX_ERR(5, 576, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 614, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 612, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_401stream_CCI, 0, __pyx_mstate_global->__pyx_n_u_stream_CCI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[226])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 612, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CCI, __pyx_t_7) < 0) __PYX_ERR(5, 612, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_403stream_CDL2CROWS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDL2CROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[227])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 647, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDL2CROWS, __pyx_t_7) < 0) __PYX_ERR(5, 647, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_405stream_CDL3BLACKCROWS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDL3BLACKCROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[228])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 683, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDL3BLACKCROWS, __pyx_t_7) < 0) __PYX_ERR(5, 683, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_407stream_CDL3INSIDE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDL3INSIDE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[229])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 719, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDL3INSIDE, __pyx_t_7) < 0) __PYX_ERR(5, 719, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_409stream_CDL3LINESTRIKE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDL3LINESTRIKE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[230])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 755, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDL3LINESTRIKE, __pyx_t_7) < 0) __PYX_ERR(5, 755, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_411stream_CDL3OUTSIDE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDL3OUTSIDE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[231])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 791, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDL3OUTSIDE, __pyx_t_7) < 0) __PYX_ERR(5, 791, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_413stream_CDL3STARSINSOUTH, 0, __pyx_mstate_global->__pyx_n_u_stream_CDL3STARSINSOUTH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[232])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 827, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDL3STARSINSOUTH, __pyx_t_7) < 0) __PYX_ERR(5, 827, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_415stream_CDL3WHITESOLDIERS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDL3WHITESOLDIERS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[233])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 863, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDL3WHITESOLDIERS, __pyx_t_7) < 0) __PYX_ERR(5, 863, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 901, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 899, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_417stream_CDLABANDONEDBABY, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLABANDONEDBABY, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[234])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 899, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLABANDONEDBABY, __pyx_t_7) < 0) __PYX_ERR(5, 899, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_419stream_CDLADVANCEBLOCK, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLADVANCEBLOCK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[235])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 937, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLADVANCEBLOCK, __pyx_t_7) < 0) __PYX_ERR(5, 937, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_421stream_CDLBELTHOLD, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLBELTHOLD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[236])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 973, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLBELTHOLD, __pyx_t_7) < 0) __PYX_ERR(5, 973, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_423stream_CDLBREAKAWAY, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLBREAKAWAY, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[237])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1009, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLBREAKAWAY, __pyx_t_7) < 0) __PYX_ERR(5, 1009, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_425stream_CDLCLOSINGMARUBOZU, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLCLOSINGMARUBOZU, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[238])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1045, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLCLOSINGMARUBOZU, __pyx_t_7) < 0) __PYX_ERR(5, 1045, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_427stream_CDLCONCEALBABYSWALL, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLCONCEALBABYSWALL, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[239])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1081, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLCONCEALBABYSWALL, __pyx_t_7) < 0) __PYX_ERR(5, 1081, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_429stream_CDLCOUNTERATTACK, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLCOUNTERATTACK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[240])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1117, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLCOUNTERATTACK, __pyx_t_7) < 0) __PYX_ERR(5, 1117, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = PyFloat_FromDouble(((double)0.5)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1155, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 1153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_431stream_CDLDARKCLOUDCOVER, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLDARKCLOUDCOVER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[241])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLDARKCLOUDCOVER, __pyx_t_7) < 0) __PYX_ERR(5, 1153, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_401stream_CCI, 0, __pyx_mstate_global->__pyx_n_u_stream_CCI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[226])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CCI, __pyx_t_19) < (0)) __PYX_ERR(5, 612, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_433stream_CDLDOJI, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[242])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1191, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLDOJI, __pyx_t_7) < 0) __PYX_ERR(5, 1191, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_403stream_CDL2CROWS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDL2CROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[227])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 647, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDL2CROWS, __pyx_t_19) < (0)) __PYX_ERR(5, 647, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_435stream_CDLDOJISTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLDOJISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[243])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1227, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLDOJISTAR, __pyx_t_7) < 0) __PYX_ERR(5, 1227, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_405stream_CDL3BLACKCROWS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDL3BLACKCROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[228])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 683, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDL3BLACKCROWS, __pyx_t_19) < (0)) __PYX_ERR(5, 683, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_437stream_CDLDRAGONFLYDOJI, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLDRAGONFLYDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[244])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1263, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLDRAGONFLYDOJI, __pyx_t_7) < 0) __PYX_ERR(5, 1263, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_407stream_CDL3INSIDE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDL3INSIDE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[229])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 719, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDL3INSIDE, __pyx_t_19) < (0)) __PYX_ERR(5, 719, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_439stream_CDLENGULFING, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLENGULFING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[245])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1299, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLENGULFING, __pyx_t_7) < 0) __PYX_ERR(5, 1299, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_409stream_CDL3LINESTRIKE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDL3LINESTRIKE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[230])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 755, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDL3LINESTRIKE, __pyx_t_19) < (0)) __PYX_ERR(5, 755, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1337, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_411stream_CDL3OUTSIDE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDL3OUTSIDE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[231])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 791, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDL3OUTSIDE, __pyx_t_19) < (0)) __PYX_ERR(5, 791, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 1335, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_441stream_CDLEVENINGDOJISTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLEVENINGDOJISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[246])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1335, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLEVENINGDOJISTAR, __pyx_t_7) < 0) __PYX_ERR(5, 1335, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_413stream_CDL3STARSINSOUTH, 0, __pyx_mstate_global->__pyx_n_u_stream_CDL3STARSINSOUTH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[232])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 827, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDL3STARSINSOUTH, __pyx_t_19) < (0)) __PYX_ERR(5, 827, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1375, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_415stream_CDL3WHITESOLDIERS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDL3WHITESOLDIERS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[233])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 863, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDL3WHITESOLDIERS, __pyx_t_19) < (0)) __PYX_ERR(5, 863, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 1373, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_443stream_CDLEVENINGSTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLEVENINGSTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[247])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1373, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLEVENINGSTAR, __pyx_t_7) < 0) __PYX_ERR(5, 1373, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_445stream_CDLGAPSIDESIDEWHITE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLGAPSIDESIDEWHITE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[248])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1411, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLGAPSIDESIDEWHITE, __pyx_t_7) < 0) __PYX_ERR(5, 1411, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_447stream_CDLGRAVESTONEDOJI, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLGRAVESTONEDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[249])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1447, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLGRAVESTONEDOJI, __pyx_t_7) < 0) __PYX_ERR(5, 1447, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_449stream_CDLHAMMER, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHAMMER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[250])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1483, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHAMMER, __pyx_t_7) < 0) __PYX_ERR(5, 1483, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_451stream_CDLHANGINGMAN, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHANGINGMAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[251])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1519, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHANGINGMAN, __pyx_t_7) < 0) __PYX_ERR(5, 1519, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_453stream_CDLHARAMI, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHARAMI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[252])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1555, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHARAMI, __pyx_t_7) < 0) __PYX_ERR(5, 1555, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_455stream_CDLHARAMICROSS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHARAMICROSS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[253])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1591, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHARAMICROSS, __pyx_t_7) < 0) __PYX_ERR(5, 1591, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_457stream_CDLHIGHWAVE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHIGHWAVE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[254])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1627, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHIGHWAVE, __pyx_t_7) < 0) __PYX_ERR(5, 1627, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_459stream_CDLHIKKAKE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHIKKAKE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[255])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1663, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHIKKAKE, __pyx_t_7) < 0) __PYX_ERR(5, 1663, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_461stream_CDLHIKKAKEMOD, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHIKKAKEMOD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[256])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1699, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHIKKAKEMOD, __pyx_t_7) < 0) __PYX_ERR(5, 1699, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_463stream_CDLHOMINGPIGEON, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHOMINGPIGEON, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[257])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1735, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHOMINGPIGEON, __pyx_t_7) < 0) __PYX_ERR(5, 1735, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_465stream_CDLIDENTICAL3CROWS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLIDENTICAL3CROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[258])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1771, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLIDENTICAL3CROWS, __pyx_t_7) < 0) __PYX_ERR(5, 1771, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_467stream_CDLINNECK, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLINNECK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[259])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1807, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLINNECK, __pyx_t_7) < 0) __PYX_ERR(5, 1807, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_469stream_CDLINVERTEDHAMMER, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLINVERTEDHAMMER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[260])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1843, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLINVERTEDHAMMER, __pyx_t_7) < 0) __PYX_ERR(5, 1843, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_471stream_CDLKICKING, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLKICKING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[261])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1879, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLKICKING, __pyx_t_7) < 0) __PYX_ERR(5, 1879, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_473stream_CDLKICKINGBYLENGTH, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLKICKINGBYLENGTH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[262])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1915, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLKICKINGBYLENGTH, __pyx_t_7) < 0) __PYX_ERR(5, 1915, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_475stream_CDLLADDERBOTTOM, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLLADDERBOTTOM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[263])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1951, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLLADDERBOTTOM, __pyx_t_7) < 0) __PYX_ERR(5, 1951, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_477stream_CDLLONGLEGGEDDOJI, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLLONGLEGGEDDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[264])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1987, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLLONGLEGGEDDOJI, __pyx_t_7) < 0) __PYX_ERR(5, 1987, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_479stream_CDLLONGLINE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLLONGLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[265])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2023, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLLONGLINE, __pyx_t_7) < 0) __PYX_ERR(5, 2023, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_481stream_CDLMARUBOZU, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLMARUBOZU, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[266])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2059, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLMARUBOZU, __pyx_t_7) < 0) __PYX_ERR(5, 2059, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_483stream_CDLMATCHINGLOW, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLMATCHINGLOW, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[267])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2095, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLMATCHINGLOW, __pyx_t_7) < 0) __PYX_ERR(5, 2095, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = PyFloat_FromDouble(((double)0.5)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2133, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 2131, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_485stream_CDLMATHOLD, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLMATHOLD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[268])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2131, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLMATHOLD, __pyx_t_7) < 0) __PYX_ERR(5, 2131, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 901, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_7 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2171, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 899, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_417stream_CDLABANDONEDBABY, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLABANDONEDBABY, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[234])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 899, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLABANDONEDBABY, __pyx_t_19) < (0)) __PYX_ERR(5, 899, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 2169, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_487stream_CDLMORNINGDOJISTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLMORNINGDOJISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[269])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2169, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLMORNINGDOJISTAR, __pyx_t_7) < 0) __PYX_ERR(5, 2169, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_419stream_CDLADVANCEBLOCK, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLADVANCEBLOCK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[235])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 937, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLADVANCEBLOCK, __pyx_t_19) < (0)) __PYX_ERR(5, 937, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2209, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_421stream_CDLBELTHOLD, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLBELTHOLD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[236])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 973, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLBELTHOLD, __pyx_t_19) < (0)) __PYX_ERR(5, 973, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 2207, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_489stream_CDLMORNINGSTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLMORNINGSTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[270])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2207, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLMORNINGSTAR, __pyx_t_7) < 0) __PYX_ERR(5, 2207, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_491stream_CDLONNECK, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLONNECK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[271])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2245, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLONNECK, __pyx_t_7) < 0) __PYX_ERR(5, 2245, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_493stream_CDLPIERCING, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLPIERCING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[272])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2281, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLPIERCING, __pyx_t_7) < 0) __PYX_ERR(5, 2281, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_495stream_CDLRICKSHAWMAN, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLRICKSHAWMAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[273])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2317, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLRICKSHAWMAN, __pyx_t_7) < 0) __PYX_ERR(5, 2317, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_497stream_CDLRISEFALL3METHODS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLRISEFALL3METHODS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[274])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2353, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLRISEFALL3METHODS, __pyx_t_7) < 0) __PYX_ERR(5, 2353, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_499stream_CDLSEPARATINGLINES, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSEPARATINGLINES, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[275])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2389, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSEPARATINGLINES, __pyx_t_7) < 0) __PYX_ERR(5, 2389, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_501stream_CDLSHOOTINGSTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSHOOTINGSTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[276])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2425, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSHOOTINGSTAR, __pyx_t_7) < 0) __PYX_ERR(5, 2425, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_503stream_CDLSHORTLINE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSHORTLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[277])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2461, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSHORTLINE, __pyx_t_7) < 0) __PYX_ERR(5, 2461, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_505stream_CDLSPINNINGTOP, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSPINNINGTOP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[278])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2497, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSPINNINGTOP, __pyx_t_7) < 0) __PYX_ERR(5, 2497, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_507stream_CDLSTALLEDPATTERN, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSTALLEDPATTERN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[279])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2533, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSTALLEDPATTERN, __pyx_t_7) < 0) __PYX_ERR(5, 2533, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_509stream_CDLSTICKSANDWICH, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSTICKSANDWICH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[280])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2569, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSTICKSANDWICH, __pyx_t_7) < 0) __PYX_ERR(5, 2569, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_511stream_CDLTAKURI, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLTAKURI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[281])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2605, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLTAKURI, __pyx_t_7) < 0) __PYX_ERR(5, 2605, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_513stream_CDLTASUKIGAP, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLTASUKIGAP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[282])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2641, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLTASUKIGAP, __pyx_t_7) < 0) __PYX_ERR(5, 2641, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_515stream_CDLTHRUSTING, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLTHRUSTING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[283])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2677, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLTHRUSTING, __pyx_t_7) < 0) __PYX_ERR(5, 2677, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_517stream_CDLTRISTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLTRISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[284])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2713, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLTRISTAR, __pyx_t_7) < 0) __PYX_ERR(5, 2713, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_519stream_CDLUNIQUE3RIVER, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLUNIQUE3RIVER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[285])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2749, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLUNIQUE3RIVER, __pyx_t_7) < 0) __PYX_ERR(5, 2749, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_521stream_CDLUPSIDEGAP2CROWS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLUPSIDEGAP2CROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[286])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2785, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLUPSIDEGAP2CROWS, __pyx_t_7) < 0) __PYX_ERR(5, 2785, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_523stream_CDLXSIDEGAP3METHODS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLXSIDEGAP3METHODS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[287])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2821, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLXSIDEGAP3METHODS, __pyx_t_7) < 0) __PYX_ERR(5, 2821, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_525stream_CEIL, 0, __pyx_mstate_global->__pyx_n_u_stream_CEIL, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[288])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2857, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CEIL, __pyx_t_7) < 0) __PYX_ERR(5, 2857, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2886, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 2884, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_527stream_CMO, 0, __pyx_mstate_global->__pyx_n_u_stream_CMO, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[289])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2884, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CMO, __pyx_t_7) < 0) __PYX_ERR(5, 2884, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_423stream_CDLBREAKAWAY, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLBREAKAWAY, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[237])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1009, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLBREAKAWAY, __pyx_t_19) < (0)) __PYX_ERR(5, 1009, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2915, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_425stream_CDLCLOSINGMARUBOZU, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLCLOSINGMARUBOZU, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[238])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1045, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLCLOSINGMARUBOZU, __pyx_t_19) < (0)) __PYX_ERR(5, 1045, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 2913, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_529stream_CORREL, 0, __pyx_mstate_global->__pyx_n_u_stream_CORREL, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[290])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2913, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CORREL, __pyx_t_7) < 0) __PYX_ERR(5, 2913, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_427stream_CDLCONCEALBABYSWALL, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLCONCEALBABYSWALL, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[239])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1081, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLCONCEALBABYSWALL, __pyx_t_19) < (0)) __PYX_ERR(5, 1081, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_531stream_COS, 0, __pyx_mstate_global->__pyx_n_u_stream_COS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[291])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2946, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_COS, __pyx_t_7) < 0) __PYX_ERR(5, 2946, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_429stream_CDLCOUNTERATTACK, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLCOUNTERATTACK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[240])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLCOUNTERATTACK, __pyx_t_19) < (0)) __PYX_ERR(5, 1117, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_533stream_COSH, 0, __pyx_mstate_global->__pyx_n_u_stream_COSH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[292])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2973, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_COSH, __pyx_t_7) < 0) __PYX_ERR(5, 2973, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = PyFloat_FromDouble(((double)0.5)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3002, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 1153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_431stream_CDLDARKCLOUDCOVER, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLDARKCLOUDCOVER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[241])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLDARKCLOUDCOVER, __pyx_t_19) < (0)) __PYX_ERR(5, 1153, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3000, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_535stream_DEMA, 0, __pyx_mstate_global->__pyx_n_u_stream_DEMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[293])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3000, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_DEMA, __pyx_t_7) < 0) __PYX_ERR(5, 3000, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_433stream_CDLDOJI, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[242])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLDOJI, __pyx_t_19) < (0)) __PYX_ERR(5, 1191, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_537stream_DIV, 0, __pyx_mstate_global->__pyx_n_u_stream_DIV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[294])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3029, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_DIV, __pyx_t_7) < 0) __PYX_ERR(5, 3029, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_435stream_CDLDOJISTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLDOJISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[243])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1227, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLDOJISTAR, __pyx_t_19) < (0)) __PYX_ERR(5, 1227, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3062, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_437stream_CDLDRAGONFLYDOJI, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLDRAGONFLYDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[244])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1263, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLDRAGONFLYDOJI, __pyx_t_19) < (0)) __PYX_ERR(5, 1263, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3060, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_539stream_DX, 0, __pyx_mstate_global->__pyx_n_u_stream_DX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[295])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3060, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_DX, __pyx_t_7) < 0) __PYX_ERR(5, 3060, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_439stream_CDLENGULFING, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLENGULFING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[245])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLENGULFING, __pyx_t_19) < (0)) __PYX_ERR(5, 1299, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3097, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1337, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3095, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_541stream_EMA, 0, __pyx_mstate_global->__pyx_n_u_stream_EMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[296])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3095, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_EMA, __pyx_t_7) < 0) __PYX_ERR(5, 3095, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_543stream_EXP, 0, __pyx_mstate_global->__pyx_n_u_stream_EXP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[297])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3124, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_EXP, __pyx_t_7) < 0) __PYX_ERR(5, 3124, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_545stream_FLOOR, 0, __pyx_mstate_global->__pyx_n_u_stream_FLOOR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[298])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3151, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_FLOOR, __pyx_t_7) < 0) __PYX_ERR(5, 3151, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_547stream_HT_DCPERIOD, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_DCPERIOD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[299])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3178, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_DCPERIOD, __pyx_t_7) < 0) __PYX_ERR(5, 3178, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_549stream_HT_DCPHASE, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_DCPHASE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[300])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3205, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_DCPHASE, __pyx_t_7) < 0) __PYX_ERR(5, 3205, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_551stream_HT_PHASOR, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_PHASOR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[301])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3232, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_PHASOR, __pyx_t_7) < 0) __PYX_ERR(5, 3232, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_553stream_HT_SINE, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_SINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[302])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3262, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_SINE, __pyx_t_7) < 0) __PYX_ERR(5, 3262, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_555stream_HT_TRENDLINE, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_TRENDLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[303])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3292, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_TRENDLINE, __pyx_t_7) < 0) __PYX_ERR(5, 3292, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_557stream_HT_TRENDMODE, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_TRENDMODE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[304])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3319, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_TRENDMODE, __pyx_t_7) < 0) __PYX_ERR(5, 3319, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3348, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3346, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_559stream_IMI, 0, __pyx_mstate_global->__pyx_n_u_stream_IMI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[305])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3346, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_IMI, __pyx_t_7) < 0) __PYX_ERR(5, 3346, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 1335, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_441stream_CDLEVENINGDOJISTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLEVENINGDOJISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[246])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1335, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLEVENINGDOJISTAR, __pyx_t_19) < (0)) __PYX_ERR(5, 1335, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3380, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1375, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3378, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_561stream_KAMA, 0, __pyx_mstate_global->__pyx_n_u_stream_KAMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[306])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3378, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_KAMA, __pyx_t_7) < 0) __PYX_ERR(5, 3378, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 1373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_443stream_CDLEVENINGSTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLEVENINGSTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[247])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLEVENINGSTAR, __pyx_t_19) < (0)) __PYX_ERR(5, 1373, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3409, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_445stream_CDLGAPSIDESIDEWHITE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLGAPSIDESIDEWHITE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[248])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLGAPSIDESIDEWHITE, __pyx_t_19) < (0)) __PYX_ERR(5, 1411, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3407, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_563stream_LINEARREG, 0, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[307])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3407, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG, __pyx_t_7) < 0) __PYX_ERR(5, 3407, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_447stream_CDLGRAVESTONEDOJI, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLGRAVESTONEDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[249])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1447, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLGRAVESTONEDOJI, __pyx_t_19) < (0)) __PYX_ERR(5, 1447, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3438, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_449stream_CDLHAMMER, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHAMMER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[250])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1483, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHAMMER, __pyx_t_19) < (0)) __PYX_ERR(5, 1483, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3436, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_565stream_LINEARREG_ANGLE, 0, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_ANGLE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[308])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3436, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_ANGLE, __pyx_t_7) < 0) __PYX_ERR(5, 3436, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_451stream_CDLHANGINGMAN, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHANGINGMAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[251])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1519, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHANGINGMAN, __pyx_t_19) < (0)) __PYX_ERR(5, 1519, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3467, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_453stream_CDLHARAMI, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHARAMI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[252])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1555, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHARAMI, __pyx_t_19) < (0)) __PYX_ERR(5, 1555, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3465, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_567stream_LINEARREG_INTERCEPT, 0, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_INTERCEPT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[309])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3465, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_INTERCEPT, __pyx_t_7) < 0) __PYX_ERR(5, 3465, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_455stream_CDLHARAMICROSS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHARAMICROSS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[253])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1591, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHARAMICROSS, __pyx_t_19) < (0)) __PYX_ERR(5, 1591, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3496, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_457stream_CDLHIGHWAVE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHIGHWAVE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[254])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1627, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHIGHWAVE, __pyx_t_19) < (0)) __PYX_ERR(5, 1627, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3494, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_569stream_LINEARREG_SLOPE, 0, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_SLOPE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[310])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3494, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_SLOPE, __pyx_t_7) < 0) __PYX_ERR(5, 3494, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_571stream_LN, 0, __pyx_mstate_global->__pyx_n_u_stream_LN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[311])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3523, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LN, __pyx_t_7) < 0) __PYX_ERR(5, 3523, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_573stream_LOG10, 0, __pyx_mstate_global->__pyx_n_u_stream_LOG10, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[312])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3550, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LOG10, __pyx_t_7) < 0) __PYX_ERR(5, 3550, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3579, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3579, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_459stream_CDLHIKKAKE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHIKKAKE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[255])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1663, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHIKKAKE, __pyx_t_19) < (0)) __PYX_ERR(5, 1663, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_20 = PyTuple_Pack(2, __pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 3577, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_575stream_MA, 0, __pyx_mstate_global->__pyx_n_u_stream_MA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[313])); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3577, __pyx_L1_error) + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_461stream_CDLHIKKAKEMOD, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHIKKAKEMOD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[256])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1699, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHIKKAKEMOD, __pyx_t_19) < (0)) __PYX_ERR(5, 1699, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_463stream_CDLHOMINGPIGEON, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHOMINGPIGEON, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[257])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1735, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHOMINGPIGEON, __pyx_t_19) < (0)) __PYX_ERR(5, 1735, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_465stream_CDLIDENTICAL3CROWS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLIDENTICAL3CROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[258])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1771, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLIDENTICAL3CROWS, __pyx_t_19) < (0)) __PYX_ERR(5, 1771, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_467stream_CDLINNECK, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLINNECK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[259])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1807, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLINNECK, __pyx_t_19) < (0)) __PYX_ERR(5, 1807, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_469stream_CDLINVERTEDHAMMER, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLINVERTEDHAMMER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[260])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1843, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLINVERTEDHAMMER, __pyx_t_19) < (0)) __PYX_ERR(5, 1843, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_471stream_CDLKICKING, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLKICKING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[261])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1879, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLKICKING, __pyx_t_19) < (0)) __PYX_ERR(5, 1879, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_473stream_CDLKICKINGBYLENGTH, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLKICKINGBYLENGTH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[262])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1915, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLKICKINGBYLENGTH, __pyx_t_19) < (0)) __PYX_ERR(5, 1915, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_475stream_CDLLADDERBOTTOM, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLLADDERBOTTOM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[263])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLLADDERBOTTOM, __pyx_t_19) < (0)) __PYX_ERR(5, 1951, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_477stream_CDLLONGLEGGEDDOJI, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLLONGLEGGEDDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[264])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1987, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLLONGLEGGEDDOJI, __pyx_t_19) < (0)) __PYX_ERR(5, 1987, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_479stream_CDLLONGLINE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLLONGLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[265])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2023, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLLONGLINE, __pyx_t_19) < (0)) __PYX_ERR(5, 2023, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_481stream_CDLMARUBOZU, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLMARUBOZU, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[266])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2059, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLMARUBOZU, __pyx_t_19) < (0)) __PYX_ERR(5, 2059, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_483stream_CDLMATCHINGLOW, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLMATCHINGLOW, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[267])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2095, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLMATCHINGLOW, __pyx_t_19) < (0)) __PYX_ERR(5, 2095, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = PyFloat_FromDouble(((double)0.5)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 2131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_485stream_CDLMATHOLD, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLMATHOLD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[268])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLMATHOLD, __pyx_t_19) < (0)) __PYX_ERR(5, 2131, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 2169, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_487stream_CDLMORNINGDOJISTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLMORNINGDOJISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[269])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2169, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLMORNINGDOJISTAR, __pyx_t_19) < (0)) __PYX_ERR(5, 2169, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 2207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_489stream_CDLMORNINGSTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLMORNINGSTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[270])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLMORNINGSTAR, __pyx_t_19) < (0)) __PYX_ERR(5, 2207, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_491stream_CDLONNECK, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLONNECK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[271])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2245, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLONNECK, __pyx_t_19) < (0)) __PYX_ERR(5, 2245, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_493stream_CDLPIERCING, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLPIERCING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[272])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLPIERCING, __pyx_t_19) < (0)) __PYX_ERR(5, 2281, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_495stream_CDLRICKSHAWMAN, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLRICKSHAWMAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[273])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2317, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLRICKSHAWMAN, __pyx_t_19) < (0)) __PYX_ERR(5, 2317, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_497stream_CDLRISEFALL3METHODS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLRISEFALL3METHODS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[274])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLRISEFALL3METHODS, __pyx_t_19) < (0)) __PYX_ERR(5, 2353, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_499stream_CDLSEPARATINGLINES, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSEPARATINGLINES, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[275])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2389, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSEPARATINGLINES, __pyx_t_19) < (0)) __PYX_ERR(5, 2389, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_501stream_CDLSHOOTINGSTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSHOOTINGSTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[276])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSHOOTINGSTAR, __pyx_t_19) < (0)) __PYX_ERR(5, 2425, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_503stream_CDLSHORTLINE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSHORTLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[277])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2461, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSHORTLINE, __pyx_t_19) < (0)) __PYX_ERR(5, 2461, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_505stream_CDLSPINNINGTOP, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSPINNINGTOP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[278])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSPINNINGTOP, __pyx_t_19) < (0)) __PYX_ERR(5, 2497, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_507stream_CDLSTALLEDPATTERN, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSTALLEDPATTERN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[279])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2533, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSTALLEDPATTERN, __pyx_t_19) < (0)) __PYX_ERR(5, 2533, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_509stream_CDLSTICKSANDWICH, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSTICKSANDWICH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[280])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2569, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSTICKSANDWICH, __pyx_t_19) < (0)) __PYX_ERR(5, 2569, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_511stream_CDLTAKURI, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLTAKURI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[281])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLTAKURI, __pyx_t_19) < (0)) __PYX_ERR(5, 2605, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_513stream_CDLTASUKIGAP, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLTASUKIGAP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[282])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2641, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLTASUKIGAP, __pyx_t_19) < (0)) __PYX_ERR(5, 2641, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_515stream_CDLTHRUSTING, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLTHRUSTING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[283])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2677, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLTHRUSTING, __pyx_t_19) < (0)) __PYX_ERR(5, 2677, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_517stream_CDLTRISTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLTRISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[284])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2713, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLTRISTAR, __pyx_t_19) < (0)) __PYX_ERR(5, 2713, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_519stream_CDLUNIQUE3RIVER, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLUNIQUE3RIVER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[285])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2749, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLUNIQUE3RIVER, __pyx_t_19) < (0)) __PYX_ERR(5, 2749, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_521stream_CDLUPSIDEGAP2CROWS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLUPSIDEGAP2CROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[286])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2785, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLUPSIDEGAP2CROWS, __pyx_t_19) < (0)) __PYX_ERR(5, 2785, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_523stream_CDLXSIDEGAP3METHODS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLXSIDEGAP3METHODS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[287])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2821, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLXSIDEGAP3METHODS, __pyx_t_19) < (0)) __PYX_ERR(5, 2821, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_525stream_CEIL, 0, __pyx_mstate_global->__pyx_n_u_stream_CEIL, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[288])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2857, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CEIL, __pyx_t_19) < (0)) __PYX_ERR(5, 2857, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2886, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 2884, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_527stream_CMO, 0, __pyx_mstate_global->__pyx_n_u_stream_CMO, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[289])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2884, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CMO, __pyx_t_19) < (0)) __PYX_ERR(5, 2884, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2915, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 2913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_529stream_CORREL, 0, __pyx_mstate_global->__pyx_n_u_stream_CORREL, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[290])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CORREL, __pyx_t_19) < (0)) __PYX_ERR(5, 2913, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_531stream_COS, 0, __pyx_mstate_global->__pyx_n_u_stream_COS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[291])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2946, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_COS, __pyx_t_19) < (0)) __PYX_ERR(5, 2946, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_533stream_COSH, 0, __pyx_mstate_global->__pyx_n_u_stream_COSH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[292])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2973, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_COSH, __pyx_t_19) < (0)) __PYX_ERR(5, 2973, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3002, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3000, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_535stream_DEMA, 0, __pyx_mstate_global->__pyx_n_u_stream_DEMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[293])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3000, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_DEMA, __pyx_t_19) < (0)) __PYX_ERR(5, 3000, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_537stream_DIV, 0, __pyx_mstate_global->__pyx_n_u_stream_DIV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[294])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3029, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_DIV, __pyx_t_19) < (0)) __PYX_ERR(5, 3029, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3062, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3060, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_539stream_DX, 0, __pyx_mstate_global->__pyx_n_u_stream_DX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[295])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3060, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_DX, __pyx_t_19) < (0)) __PYX_ERR(5, 3060, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3097, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3095, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_541stream_EMA, 0, __pyx_mstate_global->__pyx_n_u_stream_EMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[296])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3095, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_EMA, __pyx_t_19) < (0)) __PYX_ERR(5, 3095, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_543stream_EXP, 0, __pyx_mstate_global->__pyx_n_u_stream_EXP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[297])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_EXP, __pyx_t_19) < (0)) __PYX_ERR(5, 3124, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_545stream_FLOOR, 0, __pyx_mstate_global->__pyx_n_u_stream_FLOOR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[298])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_FLOOR, __pyx_t_19) < (0)) __PYX_ERR(5, 3151, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_547stream_HT_DCPERIOD, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_DCPERIOD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[299])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_DCPERIOD, __pyx_t_19) < (0)) __PYX_ERR(5, 3178, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_549stream_HT_DCPHASE, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_DCPHASE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[300])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3205, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_DCPHASE, __pyx_t_19) < (0)) __PYX_ERR(5, 3205, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_551stream_HT_PHASOR, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_PHASOR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[301])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_PHASOR, __pyx_t_19) < (0)) __PYX_ERR(5, 3232, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_553stream_HT_SINE, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_SINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[302])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3262, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_SINE, __pyx_t_19) < (0)) __PYX_ERR(5, 3262, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_555stream_HT_TRENDLINE, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_TRENDLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[303])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_TRENDLINE, __pyx_t_19) < (0)) __PYX_ERR(5, 3292, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_557stream_HT_TRENDMODE, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_TRENDMODE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[304])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3319, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_TRENDMODE, __pyx_t_19) < (0)) __PYX_ERR(5, 3319, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3346, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_559stream_IMI, 0, __pyx_mstate_global->__pyx_n_u_stream_IMI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[305])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3346, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_IMI, __pyx_t_19) < (0)) __PYX_ERR(5, 3346, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3378, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_561stream_KAMA, 0, __pyx_mstate_global->__pyx_n_u_stream_KAMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[306])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3378, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_KAMA, __pyx_t_19) < (0)) __PYX_ERR(5, 3378, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_563stream_LINEARREG, 0, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[307])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG, __pyx_t_19) < (0)) __PYX_ERR(5, 3407, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3438, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3436, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_565stream_LINEARREG_ANGLE, 0, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_ANGLE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[308])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3436, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_ANGLE, __pyx_t_19) < (0)) __PYX_ERR(5, 3436, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3467, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3465, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_567stream_LINEARREG_INTERCEPT, 0, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_INTERCEPT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[309])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3465, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_INTERCEPT, __pyx_t_19) < (0)) __PYX_ERR(5, 3465, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3496, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_569stream_LINEARREG_SLOPE, 0, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_SLOPE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[310])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_SLOPE, __pyx_t_19) < (0)) __PYX_ERR(5, 3494, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_571stream_LN, 0, __pyx_mstate_global->__pyx_n_u_stream_LN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[311])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LN, __pyx_t_19) < (0)) __PYX_ERR(5, 3523, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_573stream_LOG10, 0, __pyx_mstate_global->__pyx_n_u_stream_LOG10, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[312])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3550, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LOG10, __pyx_t_19) < (0)) __PYX_ERR(5, 3550, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __pyx_t_8 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + + __pyx_t_6 = PyTuple_Pack(2, __pyx_t_19, __pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3577, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_20); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MA, __pyx_t_6) < 0) __PYX_ERR(5, 3577, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_575stream_MA, 0, __pyx_mstate_global->__pyx_n_u_stream_MA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[313])); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3577, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_8); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_8, __pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MA, __pyx_t_8) < (0)) __PYX_ERR(5, 3577, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3609, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3609, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 3609, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3609, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3609, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_15 = PyTuple_Pack(3, __pyx_t_6, __pyx_t_20, __pyx_t_7); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 3607, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); + __pyx_t_3 = PyTuple_Pack(3, __pyx_t_8, __pyx_t_6, __pyx_t_19); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3607, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_577stream_MACD, 0, __pyx_mstate_global->__pyx_n_u_stream_MACD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[314])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3607, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_15); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MACD, __pyx_t_7) < 0) __PYX_ERR(5, 3607, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_577stream_MACD, 0, __pyx_mstate_global->__pyx_n_u_stream_MACD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[314])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3607, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MACD, __pyx_t_19) < (0)) __PYX_ERR(5, 3607, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3646, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_15 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 3646, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 3646, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __pyx_t_6 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3646, __pyx_L1_error) + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3646, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __pyx_t_3 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3646, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3646, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3646, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 3646, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3646, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - - __pyx_t_2 = PyTuple_Pack(6, __pyx_t_7, __pyx_t_15, __pyx_t_20, __pyx_t_6, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3644, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3646, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + + __pyx_t_15 = PyTuple_Pack(6, __pyx_t_19, __pyx_t_3, __pyx_t_6, __pyx_t_8, __pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 3644, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_579stream_MACDEXT, 0, __pyx_mstate_global->__pyx_n_u_stream_MACDEXT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[315])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3644, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MACDEXT, __pyx_t_3) < 0) __PYX_ERR(5, 3644, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_579stream_MACDEXT, 0, __pyx_mstate_global->__pyx_n_u_stream_MACDEXT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[315])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3644, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_15); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MACDEXT, __pyx_t_2) < (0)) __PYX_ERR(5, 3644, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3686, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3686, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); - __pyx_t_2 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3684, __pyx_L1_error) + __pyx_t_15 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 3684, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_581stream_MACDFIX, 0, __pyx_mstate_global->__pyx_n_u_stream_MACDFIX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[316])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3684, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_581stream_MACDFIX, 0, __pyx_mstate_global->__pyx_n_u_stream_MACDFIX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[316])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3684, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_15); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MACDFIX, __pyx_t_2) < (0)) __PYX_ERR(5, 3684, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MACDFIX, __pyx_t_3) < 0) __PYX_ERR(5, 3684, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3721, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3721, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); + __pyx_t_15 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 3721, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); - __pyx_t_4 = PyTuple_Pack(2, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 3719, __pyx_L1_error) + __pyx_t_4 = PyTuple_Pack(2, __pyx_t_2, __pyx_t_15); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 3719, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_583stream_MAMA, 0, __pyx_mstate_global->__pyx_n_u_stream_MAMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[317])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3719, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_4); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_583stream_MAMA, 0, __pyx_mstate_global->__pyx_n_u_stream_MAMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[317])); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 3719, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_15); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_15, __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MAMA, __pyx_t_2) < 0) __PYX_ERR(5, 3719, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MAMA, __pyx_t_15) < (0)) __PYX_ERR(5, 3719, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3754, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_15 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 3754, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 3754, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3754, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3754, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = PyTuple_Pack(3, __pyx_t_2, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3752, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_8 = PyTuple_Pack(3, __pyx_t_15, __pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3752, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_585stream_MAVP, 0, __pyx_mstate_global->__pyx_n_u_stream_MAVP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[318])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3752, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MAVP, __pyx_t_3) < 0) __PYX_ERR(5, 3752, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3789, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3787, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_587stream_MAX, 0, __pyx_mstate_global->__pyx_n_u_stream_MAX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[319])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3787, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MAX, __pyx_t_3) < 0) __PYX_ERR(5, 3787, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_585stream_MAVP, 0, __pyx_mstate_global->__pyx_n_u_stream_MAVP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[318])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3752, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MAVP, __pyx_t_2) < (0)) __PYX_ERR(5, 3752, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3818, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3789, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3816, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_589stream_MAXINDEX, 0, __pyx_mstate_global->__pyx_n_u_stream_MAXINDEX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[320])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3816, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MAXINDEX, __pyx_t_3) < 0) __PYX_ERR(5, 3816, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3787, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_587stream_MAX, 0, __pyx_mstate_global->__pyx_n_u_stream_MAX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[319])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3787, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MAX, __pyx_t_2) < (0)) __PYX_ERR(5, 3787, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_591stream_MEDPRICE, 0, __pyx_mstate_global->__pyx_n_u_stream_MEDPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[321])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3845, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MEDPRICE, __pyx_t_3) < 0) __PYX_ERR(5, 3845, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3818, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3877, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3816, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_589stream_MAXINDEX, 0, __pyx_mstate_global->__pyx_n_u_stream_MAXINDEX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[320])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3816, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MAXINDEX, __pyx_t_2) < (0)) __PYX_ERR(5, 3816, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3875, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_593stream_MFI, 0, __pyx_mstate_global->__pyx_n_u_stream_MFI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[322])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3875, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MFI, __pyx_t_3) < 0) __PYX_ERR(5, 3875, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_591stream_MEDPRICE, 0, __pyx_mstate_global->__pyx_n_u_stream_MEDPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[321])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3845, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MEDPRICE, __pyx_t_2) < (0)) __PYX_ERR(5, 3845, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3915, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3877, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3913, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_595stream_MIDPOINT, 0, __pyx_mstate_global->__pyx_n_u_stream_MIDPOINT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[323])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3913, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MIDPOINT, __pyx_t_3) < 0) __PYX_ERR(5, 3913, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3875, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_593stream_MFI, 0, __pyx_mstate_global->__pyx_n_u_stream_MFI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[322])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3875, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MFI, __pyx_t_2) < (0)) __PYX_ERR(5, 3875, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3944, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3915, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3942, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_597stream_MIDPRICE, 0, __pyx_mstate_global->__pyx_n_u_stream_MIDPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[324])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3942, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MIDPRICE, __pyx_t_3) < 0) __PYX_ERR(5, 3942, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_595stream_MIDPOINT, 0, __pyx_mstate_global->__pyx_n_u_stream_MIDPOINT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[323])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MIDPOINT, __pyx_t_2) < (0)) __PYX_ERR(5, 3913, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3976, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3944, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3974, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_599stream_MIN, 0, __pyx_mstate_global->__pyx_n_u_stream_MIN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[325])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3974, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MIN, __pyx_t_3) < 0) __PYX_ERR(5, 3974, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3942, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_597stream_MIDPRICE, 0, __pyx_mstate_global->__pyx_n_u_stream_MIDPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[324])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3942, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MIDPRICE, __pyx_t_2) < (0)) __PYX_ERR(5, 3942, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4005, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3976, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4003, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_601stream_MININDEX, 0, __pyx_mstate_global->__pyx_n_u_stream_MININDEX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[326])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4003, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MININDEX, __pyx_t_3) < 0) __PYX_ERR(5, 4003, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3974, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_599stream_MIN, 0, __pyx_mstate_global->__pyx_n_u_stream_MIN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[325])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3974, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MIN, __pyx_t_2) < (0)) __PYX_ERR(5, 3974, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4034, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4005, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4032, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_603stream_MINMAX, 0, __pyx_mstate_global->__pyx_n_u_stream_MINMAX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[327])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4032, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MINMAX, __pyx_t_3) < 0) __PYX_ERR(5, 4032, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 4003, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_601stream_MININDEX, 0, __pyx_mstate_global->__pyx_n_u_stream_MININDEX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[326])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4003, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MININDEX, __pyx_t_2) < (0)) __PYX_ERR(5, 4003, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4066, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4034, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4064, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_605stream_MINMAXINDEX, 0, __pyx_mstate_global->__pyx_n_u_stream_MINMAXINDEX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[328])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4064, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MINMAXINDEX, __pyx_t_3) < 0) __PYX_ERR(5, 4064, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 4032, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_603stream_MINMAX, 0, __pyx_mstate_global->__pyx_n_u_stream_MINMAX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[327])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4032, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MINMAX, __pyx_t_2) < (0)) __PYX_ERR(5, 4032, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4098, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4066, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4096, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_607stream_MINUS_DI, 0, __pyx_mstate_global->__pyx_n_u_stream_MINUS_DI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[329])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4096, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MINUS_DI, __pyx_t_3) < 0) __PYX_ERR(5, 4096, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 4064, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_605stream_MINMAXINDEX, 0, __pyx_mstate_global->__pyx_n_u_stream_MINMAXINDEX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[328])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4064, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MINMAXINDEX, __pyx_t_2) < (0)) __PYX_ERR(5, 4064, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4133, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4098, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4131, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_609stream_MINUS_DM, 0, __pyx_mstate_global->__pyx_n_u_stream_MINUS_DM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[330])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4131, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MINUS_DM, __pyx_t_3) < 0) __PYX_ERR(5, 4131, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 4096, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_607stream_MINUS_DI, 0, __pyx_mstate_global->__pyx_n_u_stream_MINUS_DI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[329])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4096, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MINUS_DI, __pyx_t_2) < (0)) __PYX_ERR(5, 4096, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4165, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4163, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_611stream_MOM, 0, __pyx_mstate_global->__pyx_n_u_stream_MOM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[331])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4163, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MOM, __pyx_t_3) < 0) __PYX_ERR(5, 4163, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 4131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_609stream_MINUS_DM, 0, __pyx_mstate_global->__pyx_n_u_stream_MINUS_DM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[330])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MINUS_DM, __pyx_t_2) < (0)) __PYX_ERR(5, 4131, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_613stream_MULT, 0, __pyx_mstate_global->__pyx_n_u_stream_MULT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[332])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4192, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MULT, __pyx_t_3) < 0) __PYX_ERR(5, 4192, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4225, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 4163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_611stream_MOM, 0, __pyx_mstate_global->__pyx_n_u_stream_MOM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[331])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MOM, __pyx_t_2) < (0)) __PYX_ERR(5, 4163, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4223, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_615stream_NATR, 0, __pyx_mstate_global->__pyx_n_u_stream_NATR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[333])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4223, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_NATR, __pyx_t_3) < 0) __PYX_ERR(5, 4223, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_613stream_MULT, 0, __pyx_mstate_global->__pyx_n_u_stream_MULT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[332])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MULT, __pyx_t_2) < (0)) __PYX_ERR(5, 4192, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_617stream_OBV, 0, __pyx_mstate_global->__pyx_n_u_stream_OBV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[334])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4258, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_OBV, __pyx_t_3) < 0) __PYX_ERR(5, 4258, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4291, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 4223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_615stream_NATR, 0, __pyx_mstate_global->__pyx_n_u_stream_NATR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[333])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_NATR, __pyx_t_2) < (0)) __PYX_ERR(5, 4223, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4289, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_619stream_PLUS_DI, 0, __pyx_mstate_global->__pyx_n_u_stream_PLUS_DI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[335])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4289, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_PLUS_DI, __pyx_t_3) < 0) __PYX_ERR(5, 4289, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_617stream_OBV, 0, __pyx_mstate_global->__pyx_n_u_stream_OBV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[334])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_OBV, __pyx_t_2) < (0)) __PYX_ERR(5, 4258, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4326, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4324, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_621stream_PLUS_DM, 0, __pyx_mstate_global->__pyx_n_u_stream_PLUS_DM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[336])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4324, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_PLUS_DM, __pyx_t_3) < 0) __PYX_ERR(5, 4324, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 4289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_619stream_PLUS_DI, 0, __pyx_mstate_global->__pyx_n_u_stream_PLUS_DI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[335])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_PLUS_DI, __pyx_t_2) < (0)) __PYX_ERR(5, 4289, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4358, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4358, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4326, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + __pyx_t_8 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 4324, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_621stream_PLUS_DM, 0, __pyx_mstate_global->__pyx_n_u_stream_PLUS_DM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[336])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4324, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_PLUS_DM, __pyx_t_2) < (0)) __PYX_ERR(5, 4324, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4358, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 4358, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __pyx_t_4 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4358, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 = PyTuple_Pack(3, __pyx_t_3, __pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4356, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_15 = PyTuple_Pack(3, __pyx_t_2, __pyx_t_8, __pyx_t_4); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4356, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_623stream_PPO, 0, __pyx_mstate_global->__pyx_n_u_stream_PPO, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[337])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4356, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_2); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_PPO, __pyx_t_4) < 0) __PYX_ERR(5, 4356, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_15); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_PPO, __pyx_t_4) < (0)) __PYX_ERR(5, 4356, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4389, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4387, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_15 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_625stream_ROC, 0, __pyx_mstate_global->__pyx_n_u_stream_ROC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[338])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4387, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_2); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ROC, __pyx_t_4) < 0) __PYX_ERR(5, 4387, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_15); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ROC, __pyx_t_4) < (0)) __PYX_ERR(5, 4387, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4418, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4416, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_15 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_627stream_ROCP, 0, __pyx_mstate_global->__pyx_n_u_stream_ROCP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[339])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4416, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_2); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ROCP, __pyx_t_4) < 0) __PYX_ERR(5, 4416, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_15); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ROCP, __pyx_t_4) < (0)) __PYX_ERR(5, 4416, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4447, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4445, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_15 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4445, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_629stream_ROCR, 0, __pyx_mstate_global->__pyx_n_u_stream_ROCR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[340])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4445, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_2); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ROCR, __pyx_t_4) < 0) __PYX_ERR(5, 4445, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_15); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ROCR, __pyx_t_4) < (0)) __PYX_ERR(5, 4445, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4476, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4474, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_15 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4474, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_631stream_ROCR100, 0, __pyx_mstate_global->__pyx_n_u_stream_ROCR100, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[341])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_2); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ROCR100, __pyx_t_4) < 0) __PYX_ERR(5, 4474, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_15); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ROCR100, __pyx_t_4) < (0)) __PYX_ERR(5, 4474, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4505, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4503, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_15 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4503, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_633stream_RSI, 0, __pyx_mstate_global->__pyx_n_u_stream_RSI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[342])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4503, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_2); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_RSI, __pyx_t_4) < 0) __PYX_ERR(5, 4503, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_15); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_RSI, __pyx_t_4) < (0)) __PYX_ERR(5, 4503, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = PyFloat_FromDouble(((double)0.02)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4534, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 = PyFloat_FromDouble(((double)0.2)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4534, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_15 = PyFloat_FromDouble(((double)0.2)); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4534, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); - __pyx_t_6 = PyTuple_Pack(2, __pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4532, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = PyTuple_Pack(2, __pyx_t_4, __pyx_t_15); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 4532, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_635stream_SAR, 0, __pyx_mstate_global->__pyx_n_u_stream_SAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[343])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4532, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SAR, __pyx_t_2) < 0) __PYX_ERR(5, 4532, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_635stream_SAR, 0, __pyx_mstate_global->__pyx_n_u_stream_SAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[343])); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4532, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_15); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_15, __pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SAR, __pyx_t_15) < (0)) __PYX_ERR(5, 4532, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_15 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4567, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_8 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 4567, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4567, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4567, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4567, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_4 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4567, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4567, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_20 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4567, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __pyx_t_15 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4567, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __pyx_t_7 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 4567, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 4567, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); __pyx_t_16 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4567, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __pyx_t_19 = PyTuple_Pack(8, __pyx_t_2, __pyx_t_6, __pyx_t_4, __pyx_t_3, __pyx_t_20, __pyx_t_15, __pyx_t_7, __pyx_t_16); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 4565, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_19); + __pyx_t_20 = PyTuple_Pack(8, __pyx_t_15, __pyx_t_8, __pyx_t_4, __pyx_t_2, __pyx_t_6, __pyx_t_3, __pyx_t_19, __pyx_t_16); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4565, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_20); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_637stream_SAREXT, 0, __pyx_mstate_global->__pyx_n_u_stream_SAREXT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[344])); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4565, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_16, __pyx_t_19); - __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SAREXT, __pyx_t_16) < 0) __PYX_ERR(5, 4565, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_16); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_16, __pyx_t_20); + __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SAREXT, __pyx_t_16) < (0)) __PYX_ERR(5, 4565, __pyx_L1_error) __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_639stream_SIN, 0, __pyx_mstate_global->__pyx_n_u_stream_SIN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[345])); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4604, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SIN, __pyx_t_16) < 0) __PYX_ERR(5, 4604, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_16); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SIN, __pyx_t_16) < (0)) __PYX_ERR(5, 4604, __pyx_L1_error) __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_641stream_SINH, 0, __pyx_mstate_global->__pyx_n_u_stream_SINH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[346])); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4631, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SINH, __pyx_t_16) < 0) __PYX_ERR(5, 4631, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_16); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SINH, __pyx_t_16) < (0)) __PYX_ERR(5, 4631, __pyx_L1_error) __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_16 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4660, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __pyx_t_19 = PyTuple_Pack(1, __pyx_t_16); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 4658, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_19); + __pyx_t_20 = PyTuple_Pack(1, __pyx_t_16); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4658, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_20); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_643stream_SMA, 0, __pyx_mstate_global->__pyx_n_u_stream_SMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[347])); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4658, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_16, __pyx_t_19); - __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SMA, __pyx_t_16) < 0) __PYX_ERR(5, 4658, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_16); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_16, __pyx_t_20); + __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SMA, __pyx_t_16) < (0)) __PYX_ERR(5, 4658, __pyx_L1_error) __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_645stream_SQRT, 0, __pyx_mstate_global->__pyx_n_u_stream_SQRT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[348])); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4687, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SQRT, __pyx_t_16) < 0) __PYX_ERR(5, 4687, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_16); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SQRT, __pyx_t_16) < (0)) __PYX_ERR(5, 4687, __pyx_L1_error) __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_16 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4716, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __pyx_t_19 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 4716, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_19); + __pyx_t_20 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4716, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_20); - __pyx_t_7 = PyTuple_Pack(2, __pyx_t_16, __pyx_t_19); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 4714, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_647stream_STDDEV, 0, __pyx_mstate_global->__pyx_n_u_stream_STDDEV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[349])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 4714, __pyx_L1_error) + __pyx_t_19 = PyTuple_Pack(2, __pyx_t_16, __pyx_t_20); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 4714, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_7); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_STDDEV, __pyx_t_19) < 0) __PYX_ERR(5, 4714, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_647stream_STDDEV, 0, __pyx_mstate_global->__pyx_n_u_stream_STDDEV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[349])); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4714, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_20); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_20); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_19); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_STDDEV, __pyx_t_20) < (0)) __PYX_ERR(5, 4714, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4746, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_20); __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 4746, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 4746, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); __pyx_t_16 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4746, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __pyx_t_15 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4746, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __pyx_t_20 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4746, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - - __pyx_t_3 = PyTuple_Pack(5, __pyx_t_19, __pyx_t_7, __pyx_t_16, __pyx_t_15, __pyx_t_20); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4744, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4746, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4746, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + + __pyx_t_2 = PyTuple_Pack(5, __pyx_t_20, __pyx_t_19, __pyx_t_16, __pyx_t_3, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4744, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_649stream_STOCH, 0, __pyx_mstate_global->__pyx_n_u_stream_STOCH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[350])); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4744, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_STOCH, __pyx_t_20) < 0) __PYX_ERR(5, 4744, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_649stream_STOCH, 0, __pyx_mstate_global->__pyx_n_u_stream_STOCH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[350])); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4744, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_STOCH, __pyx_t_6) < (0)) __PYX_ERR(5, 4744, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4788, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4788, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4788, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4788, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4788, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_15 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4788, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __pyx_t_16 = PyTuple_Pack(3, __pyx_t_20, __pyx_t_3, __pyx_t_15); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4786, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(3, __pyx_t_6, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4786, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_651stream_STOCHF, 0, __pyx_mstate_global->__pyx_n_u_stream_STOCHF, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[351])); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4786, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_15, __pyx_t_16); + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_651stream_STOCHF, 0, __pyx_mstate_global->__pyx_n_u_stream_STOCHF, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[351])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4786, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_STOCHF, __pyx_t_15) < 0) __PYX_ERR(5, 4786, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_STOCHF, __pyx_t_3) < (0)) __PYX_ERR(5, 4786, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_15 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4828, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __pyx_t_16 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4828, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_16); __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4828, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_20 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4828, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_16 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4828, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4828, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4828, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = PyTuple_Pack(4, __pyx_t_15, __pyx_t_16, __pyx_t_3, __pyx_t_20); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 4826, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_19 = PyTuple_Pack(4, __pyx_t_3, __pyx_t_16, __pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 4826, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_653stream_STOCHRSI, 0, __pyx_mstate_global->__pyx_n_u_stream_STOCHRSI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[352])); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4826, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_7); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_STOCHRSI, __pyx_t_20) < 0) __PYX_ERR(5, 4826, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_653stream_STOCHRSI, 0, __pyx_mstate_global->__pyx_n_u_stream_STOCHRSI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[352])); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4826, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_19); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_STOCHRSI, __pyx_t_6) < (0)) __PYX_ERR(5, 4826, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_655stream_SUB, 0, __pyx_mstate_global->__pyx_n_u_stream_SUB, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[353])); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4861, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SUB, __pyx_t_20) < 0) __PYX_ERR(5, 4861, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_655stream_SUB, 0, __pyx_mstate_global->__pyx_n_u_stream_SUB, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[353])); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4861, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SUB, __pyx_t_6) < (0)) __PYX_ERR(5, 4861, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4894, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4894, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 4892, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_657stream_SUM, 0, __pyx_mstate_global->__pyx_n_u_stream_SUM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[354])); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4892, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_7); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SUM, __pyx_t_20) < 0) __PYX_ERR(5, 4892, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __pyx_t_19 = PyTuple_Pack(1, __pyx_t_6); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 4892, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_657stream_SUM, 0, __pyx_mstate_global->__pyx_n_u_stream_SUM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[354])); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4892, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_19); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SUM, __pyx_t_6) < (0)) __PYX_ERR(5, 4892, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4923, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __pyx_t_7 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 4923, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4923, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_19 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 4923, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_3 = PyTuple_Pack(2, __pyx_t_20, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4921, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_659stream_T3, 0, __pyx_mstate_global->__pyx_n_u_stream_T3, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[355])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 4921, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_T3, __pyx_t_7) < 0) __PYX_ERR(5, 4921, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_2 = PyTuple_Pack(2, __pyx_t_6, __pyx_t_19); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4921, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_659stream_T3, 0, __pyx_mstate_global->__pyx_n_u_stream_T3, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[355])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 4921, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_T3, __pyx_t_19) < (0)) __PYX_ERR(5, 4921, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_661stream_TAN, 0, __pyx_mstate_global->__pyx_n_u_stream_TAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[356])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 4951, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TAN, __pyx_t_7) < 0) __PYX_ERR(5, 4951, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_661stream_TAN, 0, __pyx_mstate_global->__pyx_n_u_stream_TAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[356])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 4951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TAN, __pyx_t_19) < (0)) __PYX_ERR(5, 4951, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_663stream_TANH, 0, __pyx_mstate_global->__pyx_n_u_stream_TANH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[357])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 4978, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TANH, __pyx_t_7) < 0) __PYX_ERR(5, 4978, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_663stream_TANH, 0, __pyx_mstate_global->__pyx_n_u_stream_TANH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[357])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 4978, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TANH, __pyx_t_19) < (0)) __PYX_ERR(5, 4978, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 5007, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 5007, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_3 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 5005, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_665stream_TEMA, 0, __pyx_mstate_global->__pyx_n_u_stream_TEMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[358])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 5005, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TEMA, __pyx_t_7) < 0) __PYX_ERR(5, 5005, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_2 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 5005, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_665stream_TEMA, 0, __pyx_mstate_global->__pyx_n_u_stream_TEMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[358])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 5005, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TEMA, __pyx_t_19) < (0)) __PYX_ERR(5, 5005, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_667stream_TRANGE, 0, __pyx_mstate_global->__pyx_n_u_stream_TRANGE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[359])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 5034, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TRANGE, __pyx_t_7) < 0) __PYX_ERR(5, 5034, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_667stream_TRANGE, 0, __pyx_mstate_global->__pyx_n_u_stream_TRANGE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[359])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 5034, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TRANGE, __pyx_t_19) < (0)) __PYX_ERR(5, 5034, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 5069, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 5069, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_3 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 5067, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_669stream_TRIMA, 0, __pyx_mstate_global->__pyx_n_u_stream_TRIMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[360])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 5067, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TRIMA, __pyx_t_7) < 0) __PYX_ERR(5, 5067, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_2 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 5067, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_669stream_TRIMA, 0, __pyx_mstate_global->__pyx_n_u_stream_TRIMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[360])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 5067, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TRIMA, __pyx_t_19) < (0)) __PYX_ERR(5, 5067, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 5098, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 5098, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_3 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 5096, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_671stream_TRIX, 0, __pyx_mstate_global->__pyx_n_u_stream_TRIX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[361])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 5096, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TRIX, __pyx_t_7) < 0) __PYX_ERR(5, 5096, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_2 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 5096, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_671stream_TRIX, 0, __pyx_mstate_global->__pyx_n_u_stream_TRIX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[361])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 5096, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TRIX, __pyx_t_19) < (0)) __PYX_ERR(5, 5096, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 5127, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 5127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); - __pyx_t_3 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 5125, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_673stream_TSF, 0, __pyx_mstate_global->__pyx_n_u_stream_TSF, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[362])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 5125, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TSF, __pyx_t_7) < 0) __PYX_ERR(5, 5125, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_2 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 5125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_673stream_TSF, 0, __pyx_mstate_global->__pyx_n_u_stream_TSF, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[362])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 5125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TSF, __pyx_t_19) < (0)) __PYX_ERR(5, 5125, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_675stream_TYPPRICE, 0, __pyx_mstate_global->__pyx_n_u_stream_TYPPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[363])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 5154, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TYPPRICE, __pyx_t_7) < 0) __PYX_ERR(5, 5154, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_675stream_TYPPRICE, 0, __pyx_mstate_global->__pyx_n_u_stream_TYPPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[363])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 5154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TYPPRICE, __pyx_t_19) < (0)) __PYX_ERR(5, 5154, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 5189, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 5189, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 5189, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 5189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 5189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 5189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); - __pyx_t_16 = PyTuple_Pack(3, __pyx_t_7, __pyx_t_3, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 5187, __pyx_L1_error) + __pyx_t_16 = PyTuple_Pack(3, __pyx_t_19, __pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 5187, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_677stream_ULTOSC, 0, __pyx_mstate_global->__pyx_n_u_stream_ULTOSC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[364])); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 5187, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_677stream_ULTOSC, 0, __pyx_mstate_global->__pyx_n_u_stream_ULTOSC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[364])); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 5187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ULTOSC, __pyx_t_20) < 0) __PYX_ERR(5, 5187, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ULTOSC, __pyx_t_6) < (0)) __PYX_ERR(5, 5187, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 5226, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 5226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __pyx_t_16 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 5226, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __pyx_t_3 = PyTuple_Pack(2, __pyx_t_20, __pyx_t_16); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 5224, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __pyx_t_2 = PyTuple_Pack(2, __pyx_t_6, __pyx_t_16); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 5224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_679stream_VAR, 0, __pyx_mstate_global->__pyx_n_u_stream_VAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[365])); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 5224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_16, __pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_VAR, __pyx_t_16) < 0) __PYX_ERR(5, 5224, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_16); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_16, __pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_VAR, __pyx_t_16) < (0)) __PYX_ERR(5, 5224, __pyx_L1_error) __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_681stream_WCLPRICE, 0, __pyx_mstate_global->__pyx_n_u_stream_WCLPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[366])); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 5254, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_WCLPRICE, __pyx_t_16) < 0) __PYX_ERR(5, 5254, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_16); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_WCLPRICE, __pyx_t_16) < (0)) __PYX_ERR(5, 5254, __pyx_L1_error) __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_16 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 5289, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __pyx_t_3 = PyTuple_Pack(1, __pyx_t_16); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 5287, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_Pack(1, __pyx_t_16); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 5287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_683stream_WILLR, 0, __pyx_mstate_global->__pyx_n_u_stream_WILLR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[367])); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 5287, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_16, __pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_WILLR, __pyx_t_16) < 0) __PYX_ERR(5, 5287, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_16); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_16, __pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_WILLR, __pyx_t_16) < (0)) __PYX_ERR(5, 5287, __pyx_L1_error) __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_16 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 5324, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __pyx_t_3 = PyTuple_Pack(1, __pyx_t_16); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 5322, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_Pack(1, __pyx_t_16); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 5322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_685stream_WMA, 0, __pyx_mstate_global->__pyx_n_u_stream_WMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[368])); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 5322, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_16, __pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_WMA, __pyx_t_16) < 0) __PYX_ERR(5, 5322, __pyx_L1_error) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_16); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_16, __pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_WMA, __pyx_t_16) < (0)) __PYX_ERR(5, 5322, __pyx_L1_error) __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_GetModuleGlobalName(__pyx_t_16, __pyx_mstate_global->__pyx_n_u_TA_FUNCTION_NAMES); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GetModuleGlobalName(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_TA_FUNCTION_NAMES); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - if (likely(PyList_CheckExact(__pyx_t_20)) || PyTuple_CheckExact(__pyx_t_20)) { - __pyx_t_7 = __pyx_t_20; __Pyx_INCREF(__pyx_t_7); + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_TA_FUNCTION_NAMES); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (likely(PyList_CheckExact(__pyx_t_6)) || PyTuple_CheckExact(__pyx_t_6)) { + __pyx_t_19 = __pyx_t_6; __Pyx_INCREF(__pyx_t_19); __pyx_t_18 = 0; __pyx_t_33 = NULL; } else { - __pyx_t_18 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_20); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_33 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); if (unlikely(!__pyx_t_33)) __PYX_ERR(0, 8, __pyx_L1_error) + __pyx_t_18 = -1; __pyx_t_19 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __pyx_t_33 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_19); if (unlikely(!__pyx_t_33)) __PYX_ERR(0, 8, __pyx_L1_error) } - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; for (;;) { if (likely(!__pyx_t_33)) { - if (likely(PyList_CheckExact(__pyx_t_7))) { + if (likely(PyList_CheckExact(__pyx_t_19))) { { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_7); + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_19); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 8, __pyx_L1_error) #endif if (__pyx_t_18 >= __pyx_temp) break; } - __pyx_t_20 = __Pyx_PyList_GetItemRef(__pyx_t_7, __pyx_t_18); + __pyx_t_6 = __Pyx_PyList_GetItemRefFast(__pyx_t_19, __pyx_t_18, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_18; } else { { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_7); + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_19); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 8, __pyx_L1_error) #endif if (__pyx_t_18 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_20 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_18)); + __pyx_t_6 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_19, __pyx_t_18)); #else - __pyx_t_20 = __Pyx_PySequence_ITEM(__pyx_t_7, __pyx_t_18); + __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_19, __pyx_t_18); #endif ++__pyx_t_18; } - if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 8, __pyx_L1_error) + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 8, __pyx_L1_error) } else { - __pyx_t_20 = __pyx_t_33(__pyx_t_7); - if (unlikely(!__pyx_t_20)) { + __pyx_t_6 = __pyx_t_33(__pyx_t_19); + if (unlikely(!__pyx_t_6)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 8, __pyx_L1_error) @@ -86842,29 +86853,29 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); break; } } - __Pyx_GOTREF(__pyx_t_20); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_name, __pyx_t_20) < 0) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); - __pyx_t_15 = __Pyx_PyUnicode_FormatSafe(__pyx_mstate_global->__pyx_kp_u_stream__s, __pyx_t_20); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_15); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_15))) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_name, __pyx_t_6) < (0)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_mstate_global->__pyx_kp_u_stream__s, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_3))) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = PyNumber_Add(__pyx_t_16, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_t_19 = PyNumber_Add(__pyx_t_16, __pyx_t_2); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_all, __pyx_t_7) < 0) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_all, __pyx_t_19) < (0)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - __pyx_t_7 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_test, __pyx_t_7) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_19 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_test, __pyx_t_19) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; /*--- Wrapped vars code ---*/ @@ -86875,7 +86886,7 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_11); @@ -86914,997 +86925,25 @@ __Pyx_RefNannySetupContext("PyInit__ta_lib", 0); #endif } /* #### Code section: pystring_table ### */ - -typedef struct { - const char *s; -#if 1493 <= 65535 - const unsigned short n; -#elif 1493 / 2 < INT_MAX - const unsigned int n; -#elif 1493 / 2 < LONG_MAX - const unsigned long n; -#else - const Py_ssize_t n; -#endif -#if 1 <= 31 - const unsigned int encoding : 5; -#elif 1 <= 255 - const unsigned char encoding; -#elif 1 <= 65535 - const unsigned short encoding; -#else - const Py_ssize_t encoding; -#endif - const unsigned int is_unicode : 1; - const unsigned int intern : 1; -} __Pyx_StringTabEntry; -static const char * const __pyx_string_tab_encodings[] = { 0 }; -static const __Pyx_StringTabEntry __pyx_string_tab[] = { - {__pyx_k_, sizeof(__pyx_k_), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_ */ - {__pyx_k_3, sizeof(__pyx_k_3), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_3 */ - {__pyx_k_ACCBANDS, sizeof(__pyx_k_ACCBANDS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ACCBANDS */ - {__pyx_k_ACOS, sizeof(__pyx_k_ACOS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ACOS */ - {__pyx_k_AD, sizeof(__pyx_k_AD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_AD */ - {__pyx_k_ADD, sizeof(__pyx_k_ADD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ADD */ - {__pyx_k_ADOSC, sizeof(__pyx_k_ADOSC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ADOSC */ - {__pyx_k_ADX, sizeof(__pyx_k_ADX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ADX */ - {__pyx_k_ADXR, sizeof(__pyx_k_ADXR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ADXR */ - {__pyx_k_ALL, sizeof(__pyx_k_ALL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ALL */ - {__pyx_k_APO, sizeof(__pyx_k_APO), 0, 1, 1}, /* PyObject cname: __pyx_n_u_APO */ - {__pyx_k_AROON, sizeof(__pyx_k_AROON), 0, 1, 1}, /* PyObject cname: __pyx_n_u_AROON */ - {__pyx_k_AROONOSC, sizeof(__pyx_k_AROONOSC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_AROONOSC */ - {__pyx_k_ARRAY_TYPES, sizeof(__pyx_k_ARRAY_TYPES), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ARRAY_TYPES */ - {__pyx_k_ASIN, sizeof(__pyx_k_ASIN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ASIN */ - {__pyx_k_ATAN, sizeof(__pyx_k_ATAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ATAN */ - {__pyx_k_ATR, sizeof(__pyx_k_ATR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ATR */ - {__pyx_k_AVGDEV, sizeof(__pyx_k_AVGDEV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_AVGDEV */ - {__pyx_k_AVGPRICE, sizeof(__pyx_k_AVGPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_AVGPRICE */ - {__pyx_k_AllCandleSettings, sizeof(__pyx_k_AllCandleSettings), 0, 1, 1}, /* PyObject cname: __pyx_n_u_AllCandleSettings */ - {__pyx_k_Allocation_Error_TA_ALLOC_ERR, sizeof(__pyx_k_Allocation_Error_TA_ALLOC_ERR), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Allocation_Error_TA_ALLOC_ERR */ - {__pyx_k_BBANDS, sizeof(__pyx_k_BBANDS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_BBANDS */ - {__pyx_k_BETA, sizeof(__pyx_k_BETA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_BETA */ - {__pyx_k_BOP, sizeof(__pyx_k_BOP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_BOP */ - {__pyx_k_Bad_Object_TA_BAD_OBJECT, sizeof(__pyx_k_Bad_Object_TA_BAD_OBJECT), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Bad_Object_TA_BAD_OBJECT */ - {__pyx_k_Bad_Parameter_TA_BAD_PARAM, sizeof(__pyx_k_Bad_Parameter_TA_BAD_PARAM), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Bad_Parameter_TA_BAD_PARAM */ - {__pyx_k_BodyDoji, sizeof(__pyx_k_BodyDoji), 0, 1, 1}, /* PyObject cname: __pyx_n_u_BodyDoji */ - {__pyx_k_BodyLong, sizeof(__pyx_k_BodyLong), 0, 1, 1}, /* PyObject cname: __pyx_n_u_BodyLong */ - {__pyx_k_BodyShort, sizeof(__pyx_k_BodyShort), 0, 1, 1}, /* PyObject cname: __pyx_n_u_BodyShort */ - {__pyx_k_BodyVeryLong, sizeof(__pyx_k_BodyVeryLong), 0, 1, 1}, /* PyObject cname: __pyx_n_u_BodyVeryLong */ - {__pyx_k_Bull_Bear_Pattern_Bearish_0_Neut, sizeof(__pyx_k_Bull_Bear_Pattern_Bearish_0_Neut), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Bull_Bear_Pattern_Bearish_0_Neut */ - {__pyx_k_CCI, sizeof(__pyx_k_CCI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CCI */ - {__pyx_k_CDL2CROWS, sizeof(__pyx_k_CDL2CROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDL2CROWS */ - {__pyx_k_CDL3BLACKCROWS, sizeof(__pyx_k_CDL3BLACKCROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDL3BLACKCROWS */ - {__pyx_k_CDL3INSIDE, sizeof(__pyx_k_CDL3INSIDE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDL3INSIDE */ - {__pyx_k_CDL3LINESTRIKE, sizeof(__pyx_k_CDL3LINESTRIKE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDL3LINESTRIKE */ - {__pyx_k_CDL3OUTSIDE, sizeof(__pyx_k_CDL3OUTSIDE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDL3OUTSIDE */ - {__pyx_k_CDL3STARSINSOUTH, sizeof(__pyx_k_CDL3STARSINSOUTH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDL3STARSINSOUTH */ - {__pyx_k_CDL3WHITESOLDIERS, sizeof(__pyx_k_CDL3WHITESOLDIERS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDL3WHITESOLDIERS */ - {__pyx_k_CDLABANDONEDBABY, sizeof(__pyx_k_CDLABANDONEDBABY), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLABANDONEDBABY */ - {__pyx_k_CDLADVANCEBLOCK, sizeof(__pyx_k_CDLADVANCEBLOCK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLADVANCEBLOCK */ - {__pyx_k_CDLBELTHOLD, sizeof(__pyx_k_CDLBELTHOLD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLBELTHOLD */ - {__pyx_k_CDLBREAKAWAY, sizeof(__pyx_k_CDLBREAKAWAY), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLBREAKAWAY */ - {__pyx_k_CDLCLOSINGMARUBOZU, sizeof(__pyx_k_CDLCLOSINGMARUBOZU), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLCLOSINGMARUBOZU */ - {__pyx_k_CDLCONCEALBABYSWALL, sizeof(__pyx_k_CDLCONCEALBABYSWALL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLCONCEALBABYSWALL */ - {__pyx_k_CDLCOUNTERATTACK, sizeof(__pyx_k_CDLCOUNTERATTACK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLCOUNTERATTACK */ - {__pyx_k_CDLDARKCLOUDCOVER, sizeof(__pyx_k_CDLDARKCLOUDCOVER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLDARKCLOUDCOVER */ - {__pyx_k_CDLDOJI, sizeof(__pyx_k_CDLDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLDOJI */ - {__pyx_k_CDLDOJISTAR, sizeof(__pyx_k_CDLDOJISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLDOJISTAR */ - {__pyx_k_CDLDRAGONFLYDOJI, sizeof(__pyx_k_CDLDRAGONFLYDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLDRAGONFLYDOJI */ - {__pyx_k_CDLENGULFING, sizeof(__pyx_k_CDLENGULFING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLENGULFING */ - {__pyx_k_CDLEVENINGDOJISTAR, sizeof(__pyx_k_CDLEVENINGDOJISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLEVENINGDOJISTAR */ - {__pyx_k_CDLEVENINGSTAR, sizeof(__pyx_k_CDLEVENINGSTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLEVENINGSTAR */ - {__pyx_k_CDLGAPSIDESIDEWHITE, sizeof(__pyx_k_CDLGAPSIDESIDEWHITE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLGAPSIDESIDEWHITE */ - {__pyx_k_CDLGRAVESTONEDOJI, sizeof(__pyx_k_CDLGRAVESTONEDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLGRAVESTONEDOJI */ - {__pyx_k_CDLHAMMER, sizeof(__pyx_k_CDLHAMMER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLHAMMER */ - {__pyx_k_CDLHANGINGMAN, sizeof(__pyx_k_CDLHANGINGMAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLHANGINGMAN */ - {__pyx_k_CDLHARAMI, sizeof(__pyx_k_CDLHARAMI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLHARAMI */ - {__pyx_k_CDLHARAMICROSS, sizeof(__pyx_k_CDLHARAMICROSS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLHARAMICROSS */ - {__pyx_k_CDLHIGHWAVE, sizeof(__pyx_k_CDLHIGHWAVE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLHIGHWAVE */ - {__pyx_k_CDLHIKKAKE, sizeof(__pyx_k_CDLHIKKAKE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLHIKKAKE */ - {__pyx_k_CDLHIKKAKEMOD, sizeof(__pyx_k_CDLHIKKAKEMOD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLHIKKAKEMOD */ - {__pyx_k_CDLHOMINGPIGEON, sizeof(__pyx_k_CDLHOMINGPIGEON), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLHOMINGPIGEON */ - {__pyx_k_CDLIDENTICAL3CROWS, sizeof(__pyx_k_CDLIDENTICAL3CROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLIDENTICAL3CROWS */ - {__pyx_k_CDLINNECK, sizeof(__pyx_k_CDLINNECK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLINNECK */ - {__pyx_k_CDLINVERTEDHAMMER, sizeof(__pyx_k_CDLINVERTEDHAMMER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLINVERTEDHAMMER */ - {__pyx_k_CDLKICKING, sizeof(__pyx_k_CDLKICKING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLKICKING */ - {__pyx_k_CDLKICKINGBYLENGTH, sizeof(__pyx_k_CDLKICKINGBYLENGTH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLKICKINGBYLENGTH */ - {__pyx_k_CDLLADDERBOTTOM, sizeof(__pyx_k_CDLLADDERBOTTOM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLLADDERBOTTOM */ - {__pyx_k_CDLLONGLEGGEDDOJI, sizeof(__pyx_k_CDLLONGLEGGEDDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLLONGLEGGEDDOJI */ - {__pyx_k_CDLLONGLINE, sizeof(__pyx_k_CDLLONGLINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLLONGLINE */ - {__pyx_k_CDLMARUBOZU, sizeof(__pyx_k_CDLMARUBOZU), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLMARUBOZU */ - {__pyx_k_CDLMATCHINGLOW, sizeof(__pyx_k_CDLMATCHINGLOW), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLMATCHINGLOW */ - {__pyx_k_CDLMATHOLD, sizeof(__pyx_k_CDLMATHOLD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLMATHOLD */ - {__pyx_k_CDLMORNINGDOJISTAR, sizeof(__pyx_k_CDLMORNINGDOJISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLMORNINGDOJISTAR */ - {__pyx_k_CDLMORNINGSTAR, sizeof(__pyx_k_CDLMORNINGSTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLMORNINGSTAR */ - {__pyx_k_CDLONNECK, sizeof(__pyx_k_CDLONNECK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLONNECK */ - {__pyx_k_CDLPIERCING, sizeof(__pyx_k_CDLPIERCING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLPIERCING */ - {__pyx_k_CDLRICKSHAWMAN, sizeof(__pyx_k_CDLRICKSHAWMAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLRICKSHAWMAN */ - {__pyx_k_CDLRISEFALL3METHODS, sizeof(__pyx_k_CDLRISEFALL3METHODS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLRISEFALL3METHODS */ - {__pyx_k_CDLSEPARATINGLINES, sizeof(__pyx_k_CDLSEPARATINGLINES), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLSEPARATINGLINES */ - {__pyx_k_CDLSHOOTINGSTAR, sizeof(__pyx_k_CDLSHOOTINGSTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLSHOOTINGSTAR */ - {__pyx_k_CDLSHORTLINE, sizeof(__pyx_k_CDLSHORTLINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLSHORTLINE */ - {__pyx_k_CDLSPINNINGTOP, sizeof(__pyx_k_CDLSPINNINGTOP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLSPINNINGTOP */ - {__pyx_k_CDLSTALLEDPATTERN, sizeof(__pyx_k_CDLSTALLEDPATTERN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLSTALLEDPATTERN */ - {__pyx_k_CDLSTICKSANDWICH, sizeof(__pyx_k_CDLSTICKSANDWICH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLSTICKSANDWICH */ - {__pyx_k_CDLTAKURI, sizeof(__pyx_k_CDLTAKURI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLTAKURI */ - {__pyx_k_CDLTASUKIGAP, sizeof(__pyx_k_CDLTASUKIGAP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLTASUKIGAP */ - {__pyx_k_CDLTHRUSTING, sizeof(__pyx_k_CDLTHRUSTING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLTHRUSTING */ - {__pyx_k_CDLTRISTAR, sizeof(__pyx_k_CDLTRISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLTRISTAR */ - {__pyx_k_CDLUNIQUE3RIVER, sizeof(__pyx_k_CDLUNIQUE3RIVER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLUNIQUE3RIVER */ - {__pyx_k_CDLUPSIDEGAP2CROWS, sizeof(__pyx_k_CDLUPSIDEGAP2CROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLUPSIDEGAP2CROWS */ - {__pyx_k_CDLXSIDEGAP3METHODS, sizeof(__pyx_k_CDLXSIDEGAP3METHODS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLXSIDEGAP3METHODS */ - {__pyx_k_CEIL, sizeof(__pyx_k_CEIL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CEIL */ - {__pyx_k_CMO, sizeof(__pyx_k_CMO), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CMO */ - {__pyx_k_CORREL, sizeof(__pyx_k_CORREL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CORREL */ - {__pyx_k_COS, sizeof(__pyx_k_COS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_COS */ - {__pyx_k_COSH, sizeof(__pyx_k_COSH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_COSH */ - {__pyx_k_CandleSettingType, sizeof(__pyx_k_CandleSettingType), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CandleSettingType */ - {__pyx_k_DEMA, sizeof(__pyx_k_DEMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DEMA */ - {__pyx_k_DIV, sizeof(__pyx_k_DIV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DIV */ - {__pyx_k_DX, sizeof(__pyx_k_DX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DX */ - {__pyx_k_Dashed_Line, sizeof(__pyx_k_Dashed_Line), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Dashed_Line */ - {__pyx_k_DataFrame, sizeof(__pyx_k_DataFrame), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DataFrame */ - {__pyx_k_Dot, sizeof(__pyx_k_Dot), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Dot */ - {__pyx_k_Dotted_Line, sizeof(__pyx_k_Dotted_Line), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Dotted_Line */ - {__pyx_k_Double_Exponential_Moving_Averag, sizeof(__pyx_k_Double_Exponential_Moving_Averag), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Double_Exponential_Moving_Averag */ - {__pyx_k_EMA, sizeof(__pyx_k_EMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_EMA */ - {__pyx_k_EXP, sizeof(__pyx_k_EXP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_EXP */ - {__pyx_k_Equal, sizeof(__pyx_k_Equal), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Equal */ - {__pyx_k_Exponential_Moving_Average, sizeof(__pyx_k_Exponential_Moving_Average), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Exponential_Moving_Average */ - {__pyx_k_FLOOR, sizeof(__pyx_k_FLOOR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_FLOOR */ - {__pyx_k_Far, sizeof(__pyx_k_Far), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Far */ - {__pyx_k_Function, sizeof(__pyx_k_Function), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function */ - {__pyx_k_Function_Not_Found_TA_FUNC_NOT_F, sizeof(__pyx_k_Function_Not_Found_TA_FUNC_NOT_F), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Function_Not_Found_TA_FUNC_NOT_F */ - {__pyx_k_Function___call, sizeof(__pyx_k_Function___call), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function___call */ - {__pyx_k_Function___call_function, sizeof(__pyx_k_Function___call_function), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function___call_function */ - {__pyx_k_Function___check_opt_input_value, sizeof(__pyx_k_Function___check_opt_input_value), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function___check_opt_input_value */ - {__pyx_k_Function___get_opt_input_value, sizeof(__pyx_k_Function___get_opt_input_value), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function___get_opt_input_value */ - {__pyx_k_Function___init, sizeof(__pyx_k_Function___init), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function___init */ - {__pyx_k_Function___input_price_series_na, sizeof(__pyx_k_Function___input_price_series_na), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function___input_price_series_na */ - {__pyx_k_Function___local, sizeof(__pyx_k_Function___local), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function___local */ - {__pyx_k_Function___repr, sizeof(__pyx_k_Function___repr), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function___repr */ - {__pyx_k_Function___str, sizeof(__pyx_k_Function___str), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function___str */ - {__pyx_k_Function___unicode, sizeof(__pyx_k_Function___unicode), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function___unicode */ - {__pyx_k_Function__call_function, sizeof(__pyx_k_Function__call_function), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function__call_function */ - {__pyx_k_Function__check_opt_input_value, sizeof(__pyx_k_Function__check_opt_input_value), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function__check_opt_input_value */ - {__pyx_k_Function__get_opt_input_value, sizeof(__pyx_k_Function__get_opt_input_value), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function__get_opt_input_value */ - {__pyx_k_Function__input_price_series_na, sizeof(__pyx_k_Function__input_price_series_na), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function__input_price_series_na */ - {__pyx_k_Function__local, sizeof(__pyx_k_Function__local), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function__local */ - {__pyx_k_Function__localdata, sizeof(__pyx_k_Function__localdata), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function__localdata */ - {__pyx_k_Function__name, sizeof(__pyx_k_Function__name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function__name */ - {__pyx_k_Function__namestr, sizeof(__pyx_k_Function__namestr), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function__namestr */ - {__pyx_k_Function_function_flags, sizeof(__pyx_k_Function_function_flags), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_function_flags */ - {__pyx_k_Function_get_input_arrays, sizeof(__pyx_k_Function_get_input_arrays), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_get_input_arrays */ - {__pyx_k_Function_get_input_names, sizeof(__pyx_k_Function_get_input_names), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_get_input_names */ - {__pyx_k_Function_get_parameters, sizeof(__pyx_k_Function_get_parameters), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_get_parameters */ - {__pyx_k_Function_has_an_unstable_period, sizeof(__pyx_k_Function_has_an_unstable_period), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Function_has_an_unstable_period */ - {__pyx_k_Function_info, sizeof(__pyx_k_Function_info), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_info */ - {__pyx_k_Function_lookback, sizeof(__pyx_k_Function_lookback), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_lookback */ - {__pyx_k_Function_output_flags, sizeof(__pyx_k_Function_output_flags), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_output_flags */ - {__pyx_k_Function_output_names, sizeof(__pyx_k_Function_output_names), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_output_names */ - {__pyx_k_Function_outputs, sizeof(__pyx_k_Function_outputs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_outputs */ - {__pyx_k_Function_run, sizeof(__pyx_k_Function_run), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_run */ - {__pyx_k_Function_set_function_args, sizeof(__pyx_k_Function_set_function_args), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_set_function_args */ - {__pyx_k_Function_set_input_arrays, sizeof(__pyx_k_Function_set_input_arrays), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_set_input_arrays */ - {__pyx_k_Function_set_input_names, sizeof(__pyx_k_Function_set_input_names), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_set_input_names */ - {__pyx_k_Function_set_parameters, sizeof(__pyx_k_Function_set_parameters), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_set_parameters */ - {__pyx_k_Group_Not_Found_TA_GROUP_NOT_FOU, sizeof(__pyx_k_Group_Not_Found_TA_GROUP_NOT_FOU), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Group_Not_Found_TA_GROUP_NOT_FOU */ - {__pyx_k_HT_DCPERIOD, sizeof(__pyx_k_HT_DCPERIOD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_HT_DCPERIOD */ - {__pyx_k_HT_DCPHASE, sizeof(__pyx_k_HT_DCPHASE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_HT_DCPHASE */ - {__pyx_k_HT_PHASOR, sizeof(__pyx_k_HT_PHASOR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_HT_PHASOR */ - {__pyx_k_HT_SINE, sizeof(__pyx_k_HT_SINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_HT_SINE */ - {__pyx_k_HT_TRENDLINE, sizeof(__pyx_k_HT_TRENDLINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_HT_TRENDLINE */ - {__pyx_k_HT_TRENDMODE, sizeof(__pyx_k_HT_TRENDMODE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_HT_TRENDMODE */ - {__pyx_k_HighLow, sizeof(__pyx_k_HighLow), 0, 1, 1}, /* PyObject cname: __pyx_n_u_HighLow */ - {__pyx_k_Histogram, sizeof(__pyx_k_Histogram), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Histogram */ - {__pyx_k_IMI, sizeof(__pyx_k_IMI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_IMI */ - {__pyx_k_INPUT_ARRAYS_TYPES, sizeof(__pyx_k_INPUT_ARRAYS_TYPES), 0, 1, 1}, /* PyObject cname: __pyx_n_u_INPUT_ARRAYS_TYPES */ - {__pyx_k_INPUT_PRICE_SERIES_DEFAULTS, sizeof(__pyx_k_INPUT_PRICE_SERIES_DEFAULTS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_INPUT_PRICE_SERIES_DEFAULTS */ - {__pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ImportError */ - {__pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_IndexError */ - {__pyx_k_Input_Not_All_Initialized_TA_INP, sizeof(__pyx_k_Input_Not_All_Initialized_TA_INP), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Input_Not_All_Initialized_TA_INP */ - {__pyx_k_Inputs, sizeof(__pyx_k_Inputs), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Inputs */ - {__pyx_k_Internal_Error_TA_INTERNAL_ERROR, sizeof(__pyx_k_Internal_Error_TA_INTERNAL_ERROR), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Internal_Error_TA_INTERNAL_ERROR */ - {__pyx_k_Invalid_Handle_TA_INVALID_HANDLE, sizeof(__pyx_k_Invalid_Handle_TA_INVALID_HANDLE), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Invalid_Handle_TA_INVALID_HANDLE */ - {__pyx_k_Invalid_List_Type_TA_INVALID_LIS, sizeof(__pyx_k_Invalid_List_Type_TA_INVALID_LIS), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Invalid_List_Type_TA_INVALID_LIS */ - {__pyx_k_Invalid_Parameter_Function_TA_IN, sizeof(__pyx_k_Invalid_Parameter_Function_TA_IN), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Invalid_Parameter_Function_TA_IN */ - {__pyx_k_Invalid_Parameter_Holder_TA_INVA, sizeof(__pyx_k_Invalid_Parameter_Holder_TA_INVA), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Invalid_Parameter_Holder_TA_INVA */ - {__pyx_k_Invalid_Parameter_Holder_Type_TA, sizeof(__pyx_k_Invalid_Parameter_Holder_Type_TA), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Invalid_Parameter_Holder_Type_TA */ - {__pyx_k_Invalid_parameter_value_for, sizeof(__pyx_k_Invalid_parameter_value_for), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Invalid_parameter_value_for */ - {__pyx_k_KAMA, sizeof(__pyx_k_KAMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_KAMA */ - {__pyx_k_Kaufman_Adaptive_Moving_Average, sizeof(__pyx_k_Kaufman_Adaptive_Moving_Average), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Kaufman_Adaptive_Moving_Average */ - {__pyx_k_LINEARREG, sizeof(__pyx_k_LINEARREG), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LINEARREG */ - {__pyx_k_LINEARREG_ANGLE, sizeof(__pyx_k_LINEARREG_ANGLE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LINEARREG_ANGLE */ - {__pyx_k_LINEARREG_INTERCEPT, sizeof(__pyx_k_LINEARREG_INTERCEPT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LINEARREG_INTERCEPT */ - {__pyx_k_LINEARREG_SLOPE, sizeof(__pyx_k_LINEARREG_SLOPE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LINEARREG_SLOPE */ - {__pyx_k_LN, sizeof(__pyx_k_LN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LN */ - {__pyx_k_LOG10, sizeof(__pyx_k_LOG10), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LOG10 */ - {__pyx_k_Library_Not_Initialized_TA_LIB_N, sizeof(__pyx_k_Library_Not_Initialized_TA_LIB_N), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Library_Not_Initialized_TA_LIB_N */ - {__pyx_k_Line, sizeof(__pyx_k_Line), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Line */ - {__pyx_k_MA, sizeof(__pyx_k_MA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MA */ - {__pyx_k_MACD, sizeof(__pyx_k_MACD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MACD */ - {__pyx_k_MACDEXT, sizeof(__pyx_k_MACDEXT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MACDEXT */ - {__pyx_k_MACDFIX, sizeof(__pyx_k_MACDFIX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MACDFIX */ - {__pyx_k_MAMA, sizeof(__pyx_k_MAMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MAMA */ - {__pyx_k_MAVP, sizeof(__pyx_k_MAVP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MAVP */ - {__pyx_k_MAX, sizeof(__pyx_k_MAX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MAX */ - {__pyx_k_MAXINDEX, sizeof(__pyx_k_MAXINDEX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MAXINDEX */ - {__pyx_k_MA_Type, sizeof(__pyx_k_MA_Type), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MA_Type */ - {__pyx_k_MA_Type___getitem, sizeof(__pyx_k_MA_Type___getitem), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MA_Type___getitem */ - {__pyx_k_MA_Type___init, sizeof(__pyx_k_MA_Type___init), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MA_Type___init */ - {__pyx_k_MEDPRICE, sizeof(__pyx_k_MEDPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MEDPRICE */ - {__pyx_k_MESA_Adaptive_Moving_Average, sizeof(__pyx_k_MESA_Adaptive_Moving_Average), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_MESA_Adaptive_Moving_Average */ - {__pyx_k_MFI, sizeof(__pyx_k_MFI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MFI */ - {__pyx_k_MIDPOINT, sizeof(__pyx_k_MIDPOINT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MIDPOINT */ - {__pyx_k_MIDPRICE, sizeof(__pyx_k_MIDPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MIDPRICE */ - {__pyx_k_MIN, sizeof(__pyx_k_MIN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MIN */ - {__pyx_k_MININDEX, sizeof(__pyx_k_MININDEX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MININDEX */ - {__pyx_k_MINMAX, sizeof(__pyx_k_MINMAX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MINMAX */ - {__pyx_k_MINMAXINDEX, sizeof(__pyx_k_MINMAXINDEX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MINMAXINDEX */ - {__pyx_k_MINUS_DI, sizeof(__pyx_k_MINUS_DI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MINUS_DI */ - {__pyx_k_MINUS_DM, sizeof(__pyx_k_MINUS_DM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MINUS_DM */ - {__pyx_k_MOM, sizeof(__pyx_k_MOM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MOM */ - {__pyx_k_MULT, sizeof(__pyx_k_MULT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MULT */ - {__pyx_k_ModuleNotFoundError, sizeof(__pyx_k_ModuleNotFoundError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ModuleNotFoundError */ - {__pyx_k_NATR, sizeof(__pyx_k_NATR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_NATR */ - {__pyx_k_NONE, sizeof(__pyx_k_NONE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_NONE */ - {__pyx_k_NameError, sizeof(__pyx_k_NameError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_NameError */ - {__pyx_k_Near, sizeof(__pyx_k_Near), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Near */ - {__pyx_k_None, sizeof(__pyx_k_None), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_None */ - {__pyx_k_Not_Supported_TA_NOT_SUPPORTED, sizeof(__pyx_k_Not_Supported_TA_NOT_SUPPORTED), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Not_Supported_TA_NOT_SUPPORTED */ - {__pyx_k_Not_enough_price_arguments_expec, sizeof(__pyx_k_Not_enough_price_arguments_expec), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Not_enough_price_arguments_expec */ - {__pyx_k_Note_that_Cython_is_deliberately, sizeof(__pyx_k_Note_that_Cython_is_deliberately), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Note_that_Cython_is_deliberately */ - {__pyx_k_OBV, sizeof(__pyx_k_OBV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_OBV */ - {__pyx_k_OrderedDict, sizeof(__pyx_k_OrderedDict), 0, 1, 1}, /* PyObject cname: __pyx_n_u_OrderedDict */ - {__pyx_k_Out_of_Range_End_Index_TA_OUT_OF, sizeof(__pyx_k_Out_of_Range_End_Index_TA_OUT_OF), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Out_of_Range_End_Index_TA_OUT_OF */ - {__pyx_k_Out_of_Range_Start_Index_TA_OUT, sizeof(__pyx_k_Out_of_Range_Start_Index_TA_OUT), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Out_of_Range_Start_Index_TA_OUT */ - {__pyx_k_Output_Not_All_Initialized_TA_OU, sizeof(__pyx_k_Output_Not_All_Initialized_TA_OU), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Output_Not_All_Initialized_TA_OU */ - {__pyx_k_Output_can_be_negative, sizeof(__pyx_k_Output_can_be_negative), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Output_can_be_negative */ - {__pyx_k_Output_can_be_positive, sizeof(__pyx_k_Output_can_be_positive), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Output_can_be_positive */ - {__pyx_k_Output_can_be_zero, sizeof(__pyx_k_Output_can_be_zero), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Output_can_be_zero */ - {__pyx_k_Output_is_a_candlestick, sizeof(__pyx_k_Output_is_a_candlestick), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Output_is_a_candlestick */ - {__pyx_k_Output_is_over_volume, sizeof(__pyx_k_Output_is_over_volume), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Output_is_over_volume */ - {__pyx_k_Output_scale_same_as_input, sizeof(__pyx_k_Output_scale_same_as_input), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Output_scale_same_as_input */ - {__pyx_k_Outputs, sizeof(__pyx_k_Outputs), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Outputs */ - {__pyx_k_PANDAS_DATAFRAME, sizeof(__pyx_k_PANDAS_DATAFRAME), 0, 1, 1}, /* PyObject cname: __pyx_n_u_PANDAS_DATAFRAME */ - {__pyx_k_PANDAS_SERIES, sizeof(__pyx_k_PANDAS_SERIES), 0, 1, 1}, /* PyObject cname: __pyx_n_u_PANDAS_SERIES */ - {__pyx_k_PLUS_DI, sizeof(__pyx_k_PLUS_DI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_PLUS_DI */ - {__pyx_k_PLUS_DM, sizeof(__pyx_k_PLUS_DM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_PLUS_DM */ - {__pyx_k_POLARS_DATAFRAME, sizeof(__pyx_k_POLARS_DATAFRAME), 0, 1, 1}, /* PyObject cname: __pyx_n_u_POLARS_DATAFRAME */ - {__pyx_k_POLARS_SERIES, sizeof(__pyx_k_POLARS_SERIES), 0, 1, 1}, /* PyObject cname: __pyx_n_u_POLARS_SERIES */ - {__pyx_k_PPO, sizeof(__pyx_k_PPO), 0, 1, 1}, /* PyObject cname: __pyx_n_u_PPO */ - {__pyx_k_Parameters, sizeof(__pyx_k_Parameters), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Parameters */ - {__pyx_k_Pattern_Bool, sizeof(__pyx_k_Pattern_Bool), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Pattern_Bool */ - {__pyx_k_ROC, sizeof(__pyx_k_ROC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ROC */ - {__pyx_k_ROCP, sizeof(__pyx_k_ROCP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ROCP */ - {__pyx_k_ROCR, sizeof(__pyx_k_ROCR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ROCR */ - {__pyx_k_ROCR100, sizeof(__pyx_k_ROCR100), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ROCR100 */ - {__pyx_k_RSI, sizeof(__pyx_k_RSI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_RSI */ - {__pyx_k_RangeType, sizeof(__pyx_k_RangeType), 0, 1, 1}, /* PyObject cname: __pyx_n_u_RangeType */ - {__pyx_k_RealBody, sizeof(__pyx_k_RealBody), 0, 1, 1}, /* PyObject cname: __pyx_n_u_RealBody */ - {__pyx_k_SAR, sizeof(__pyx_k_SAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SAR */ - {__pyx_k_SAREXT, sizeof(__pyx_k_SAREXT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SAREXT */ - {__pyx_k_SIN, sizeof(__pyx_k_SIN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SIN */ - {__pyx_k_SINH, sizeof(__pyx_k_SINH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SINH */ - {__pyx_k_SMA, sizeof(__pyx_k_SMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SMA */ - {__pyx_k_SQRT, sizeof(__pyx_k_SQRT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SQRT */ - {__pyx_k_STDDEV, sizeof(__pyx_k_STDDEV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_STDDEV */ - {__pyx_k_STOCH, sizeof(__pyx_k_STOCH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_STOCH */ - {__pyx_k_STOCHF, sizeof(__pyx_k_STOCHF), 0, 1, 1}, /* PyObject cname: __pyx_n_u_STOCHF */ - {__pyx_k_STOCHRSI, sizeof(__pyx_k_STOCHRSI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_STOCHRSI */ - {__pyx_k_SUB, sizeof(__pyx_k_SUB), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SUB */ - {__pyx_k_SUM, sizeof(__pyx_k_SUM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SUM */ - {__pyx_k_Series, sizeof(__pyx_k_Series), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Series */ - {__pyx_k_ShadowLong, sizeof(__pyx_k_ShadowLong), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ShadowLong */ - {__pyx_k_ShadowShort, sizeof(__pyx_k_ShadowShort), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ShadowShort */ - {__pyx_k_ShadowVeryLong, sizeof(__pyx_k_ShadowVeryLong), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ShadowVeryLong */ - {__pyx_k_ShadowVeryShort, sizeof(__pyx_k_ShadowVeryShort), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ShadowVeryShort */ - {__pyx_k_Shadows, sizeof(__pyx_k_Shadows), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Shadows */ - {__pyx_k_Simple_Moving_Average, sizeof(__pyx_k_Simple_Moving_Average), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Simple_Moving_Average */ - {__pyx_k_Strength_Pattern_200_100_Bearish, sizeof(__pyx_k_Strength_Pattern_200_100_Bearish), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Strength_Pattern_200_100_Bearish */ - {__pyx_k_T3, sizeof(__pyx_k_T3), 0, 1, 1}, /* PyObject cname: __pyx_n_u_T3 */ - {__pyx_k_TAN, sizeof(__pyx_k_TAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TAN */ - {__pyx_k_TANH, sizeof(__pyx_k_TANH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TANH */ - {__pyx_k_TA_ACCBANDS, sizeof(__pyx_k_TA_ACCBANDS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ACCBANDS */ - {__pyx_k_TA_ACOS, sizeof(__pyx_k_TA_ACOS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ACOS */ - {__pyx_k_TA_AD, sizeof(__pyx_k_TA_AD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_AD */ - {__pyx_k_TA_ADD, sizeof(__pyx_k_TA_ADD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ADD */ - {__pyx_k_TA_ADOSC, sizeof(__pyx_k_TA_ADOSC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ADOSC */ - {__pyx_k_TA_ADX, sizeof(__pyx_k_TA_ADX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ADX */ - {__pyx_k_TA_ADXR, sizeof(__pyx_k_TA_ADXR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ADXR */ - {__pyx_k_TA_APO, sizeof(__pyx_k_TA_APO), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_APO */ - {__pyx_k_TA_AROON, sizeof(__pyx_k_TA_AROON), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_AROON */ - {__pyx_k_TA_AROONOSC, sizeof(__pyx_k_TA_AROONOSC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_AROONOSC */ - {__pyx_k_TA_ASIN, sizeof(__pyx_k_TA_ASIN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ASIN */ - {__pyx_k_TA_ATAN, sizeof(__pyx_k_TA_ATAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ATAN */ - {__pyx_k_TA_ATR, sizeof(__pyx_k_TA_ATR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ATR */ - {__pyx_k_TA_AVGDEV, sizeof(__pyx_k_TA_AVGDEV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_AVGDEV */ - {__pyx_k_TA_AVGPRICE, sizeof(__pyx_k_TA_AVGPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_AVGPRICE */ - {__pyx_k_TA_BBANDS, sizeof(__pyx_k_TA_BBANDS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_BBANDS */ - {__pyx_k_TA_BETA, sizeof(__pyx_k_TA_BETA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_BETA */ - {__pyx_k_TA_BOP, sizeof(__pyx_k_TA_BOP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_BOP */ - {__pyx_k_TA_CCI, sizeof(__pyx_k_TA_CCI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CCI */ - {__pyx_k_TA_CDL2CROWS, sizeof(__pyx_k_TA_CDL2CROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDL2CROWS */ - {__pyx_k_TA_CDL3BLACKCROWS, sizeof(__pyx_k_TA_CDL3BLACKCROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDL3BLACKCROWS */ - {__pyx_k_TA_CDL3INSIDE, sizeof(__pyx_k_TA_CDL3INSIDE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDL3INSIDE */ - {__pyx_k_TA_CDL3LINESTRIKE, sizeof(__pyx_k_TA_CDL3LINESTRIKE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDL3LINESTRIKE */ - {__pyx_k_TA_CDL3OUTSIDE, sizeof(__pyx_k_TA_CDL3OUTSIDE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDL3OUTSIDE */ - {__pyx_k_TA_CDL3STARSINSOUTH, sizeof(__pyx_k_TA_CDL3STARSINSOUTH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDL3STARSINSOUTH */ - {__pyx_k_TA_CDL3WHITESOLDIERS, sizeof(__pyx_k_TA_CDL3WHITESOLDIERS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDL3WHITESOLDIERS */ - {__pyx_k_TA_CDLABANDONEDBABY, sizeof(__pyx_k_TA_CDLABANDONEDBABY), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLABANDONEDBABY */ - {__pyx_k_TA_CDLADVANCEBLOCK, sizeof(__pyx_k_TA_CDLADVANCEBLOCK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLADVANCEBLOCK */ - {__pyx_k_TA_CDLBELTHOLD, sizeof(__pyx_k_TA_CDLBELTHOLD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLBELTHOLD */ - {__pyx_k_TA_CDLBREAKAWAY, sizeof(__pyx_k_TA_CDLBREAKAWAY), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLBREAKAWAY */ - {__pyx_k_TA_CDLCLOSINGMARUBOZU, sizeof(__pyx_k_TA_CDLCLOSINGMARUBOZU), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLCLOSINGMARUBOZU */ - {__pyx_k_TA_CDLCONCEALBABYSWALL, sizeof(__pyx_k_TA_CDLCONCEALBABYSWALL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLCONCEALBABYSWALL */ - {__pyx_k_TA_CDLCOUNTERATTACK, sizeof(__pyx_k_TA_CDLCOUNTERATTACK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLCOUNTERATTACK */ - {__pyx_k_TA_CDLDARKCLOUDCOVER, sizeof(__pyx_k_TA_CDLDARKCLOUDCOVER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLDARKCLOUDCOVER */ - {__pyx_k_TA_CDLDOJI, sizeof(__pyx_k_TA_CDLDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLDOJI */ - {__pyx_k_TA_CDLDOJISTAR, sizeof(__pyx_k_TA_CDLDOJISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLDOJISTAR */ - {__pyx_k_TA_CDLDRAGONFLYDOJI, sizeof(__pyx_k_TA_CDLDRAGONFLYDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLDRAGONFLYDOJI */ - {__pyx_k_TA_CDLENGULFING, sizeof(__pyx_k_TA_CDLENGULFING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLENGULFING */ - {__pyx_k_TA_CDLEVENINGDOJISTAR, sizeof(__pyx_k_TA_CDLEVENINGDOJISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLEVENINGDOJISTAR */ - {__pyx_k_TA_CDLEVENINGSTAR, sizeof(__pyx_k_TA_CDLEVENINGSTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLEVENINGSTAR */ - {__pyx_k_TA_CDLGAPSIDESIDEWHITE, sizeof(__pyx_k_TA_CDLGAPSIDESIDEWHITE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLGAPSIDESIDEWHITE */ - {__pyx_k_TA_CDLGRAVESTONEDOJI, sizeof(__pyx_k_TA_CDLGRAVESTONEDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLGRAVESTONEDOJI */ - {__pyx_k_TA_CDLHAMMER, sizeof(__pyx_k_TA_CDLHAMMER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLHAMMER */ - {__pyx_k_TA_CDLHANGINGMAN, sizeof(__pyx_k_TA_CDLHANGINGMAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLHANGINGMAN */ - {__pyx_k_TA_CDLHARAMI, sizeof(__pyx_k_TA_CDLHARAMI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLHARAMI */ - {__pyx_k_TA_CDLHARAMICROSS, sizeof(__pyx_k_TA_CDLHARAMICROSS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLHARAMICROSS */ - {__pyx_k_TA_CDLHIGHWAVE, sizeof(__pyx_k_TA_CDLHIGHWAVE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLHIGHWAVE */ - {__pyx_k_TA_CDLHIKKAKE, sizeof(__pyx_k_TA_CDLHIKKAKE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLHIKKAKE */ - {__pyx_k_TA_CDLHIKKAKEMOD, sizeof(__pyx_k_TA_CDLHIKKAKEMOD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLHIKKAKEMOD */ - {__pyx_k_TA_CDLHOMINGPIGEON, sizeof(__pyx_k_TA_CDLHOMINGPIGEON), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLHOMINGPIGEON */ - {__pyx_k_TA_CDLIDENTICAL3CROWS, sizeof(__pyx_k_TA_CDLIDENTICAL3CROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLIDENTICAL3CROWS */ - {__pyx_k_TA_CDLINNECK, sizeof(__pyx_k_TA_CDLINNECK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLINNECK */ - {__pyx_k_TA_CDLINVERTEDHAMMER, sizeof(__pyx_k_TA_CDLINVERTEDHAMMER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLINVERTEDHAMMER */ - {__pyx_k_TA_CDLKICKING, sizeof(__pyx_k_TA_CDLKICKING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLKICKING */ - {__pyx_k_TA_CDLKICKINGBYLENGTH, sizeof(__pyx_k_TA_CDLKICKINGBYLENGTH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLKICKINGBYLENGTH */ - {__pyx_k_TA_CDLLADDERBOTTOM, sizeof(__pyx_k_TA_CDLLADDERBOTTOM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLLADDERBOTTOM */ - {__pyx_k_TA_CDLLONGLEGGEDDOJI, sizeof(__pyx_k_TA_CDLLONGLEGGEDDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLLONGLEGGEDDOJI */ - {__pyx_k_TA_CDLLONGLINE, sizeof(__pyx_k_TA_CDLLONGLINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLLONGLINE */ - {__pyx_k_TA_CDLMARUBOZU, sizeof(__pyx_k_TA_CDLMARUBOZU), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLMARUBOZU */ - {__pyx_k_TA_CDLMATCHINGLOW, sizeof(__pyx_k_TA_CDLMATCHINGLOW), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLMATCHINGLOW */ - {__pyx_k_TA_CDLMATHOLD, sizeof(__pyx_k_TA_CDLMATHOLD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLMATHOLD */ - {__pyx_k_TA_CDLMORNINGDOJISTAR, sizeof(__pyx_k_TA_CDLMORNINGDOJISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLMORNINGDOJISTAR */ - {__pyx_k_TA_CDLMORNINGSTAR, sizeof(__pyx_k_TA_CDLMORNINGSTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLMORNINGSTAR */ - {__pyx_k_TA_CDLONNECK, sizeof(__pyx_k_TA_CDLONNECK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLONNECK */ - {__pyx_k_TA_CDLPIERCING, sizeof(__pyx_k_TA_CDLPIERCING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLPIERCING */ - {__pyx_k_TA_CDLRICKSHAWMAN, sizeof(__pyx_k_TA_CDLRICKSHAWMAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLRICKSHAWMAN */ - {__pyx_k_TA_CDLRISEFALL3METHODS, sizeof(__pyx_k_TA_CDLRISEFALL3METHODS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLRISEFALL3METHODS */ - {__pyx_k_TA_CDLSEPARATINGLINES, sizeof(__pyx_k_TA_CDLSEPARATINGLINES), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLSEPARATINGLINES */ - {__pyx_k_TA_CDLSHOOTINGSTAR, sizeof(__pyx_k_TA_CDLSHOOTINGSTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLSHOOTINGSTAR */ - {__pyx_k_TA_CDLSHORTLINE, sizeof(__pyx_k_TA_CDLSHORTLINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLSHORTLINE */ - {__pyx_k_TA_CDLSPINNINGTOP, sizeof(__pyx_k_TA_CDLSPINNINGTOP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLSPINNINGTOP */ - {__pyx_k_TA_CDLSTALLEDPATTERN, sizeof(__pyx_k_TA_CDLSTALLEDPATTERN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLSTALLEDPATTERN */ - {__pyx_k_TA_CDLSTICKSANDWICH, sizeof(__pyx_k_TA_CDLSTICKSANDWICH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLSTICKSANDWICH */ - {__pyx_k_TA_CDLTAKURI, sizeof(__pyx_k_TA_CDLTAKURI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLTAKURI */ - {__pyx_k_TA_CDLTASUKIGAP, sizeof(__pyx_k_TA_CDLTASUKIGAP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLTASUKIGAP */ - {__pyx_k_TA_CDLTHRUSTING, sizeof(__pyx_k_TA_CDLTHRUSTING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLTHRUSTING */ - {__pyx_k_TA_CDLTRISTAR, sizeof(__pyx_k_TA_CDLTRISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLTRISTAR */ - {__pyx_k_TA_CDLUNIQUE3RIVER, sizeof(__pyx_k_TA_CDLUNIQUE3RIVER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLUNIQUE3RIVER */ - {__pyx_k_TA_CDLUPSIDEGAP2CROWS, sizeof(__pyx_k_TA_CDLUPSIDEGAP2CROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLUPSIDEGAP2CROWS */ - {__pyx_k_TA_CDLXSIDEGAP3METHODS, sizeof(__pyx_k_TA_CDLXSIDEGAP3METHODS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLXSIDEGAP3METHODS */ - {__pyx_k_TA_CEIL, sizeof(__pyx_k_TA_CEIL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CEIL */ - {__pyx_k_TA_CMO, sizeof(__pyx_k_TA_CMO), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CMO */ - {__pyx_k_TA_CORREL, sizeof(__pyx_k_TA_CORREL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CORREL */ - {__pyx_k_TA_COS, sizeof(__pyx_k_TA_COS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_COS */ - {__pyx_k_TA_COSH, sizeof(__pyx_k_TA_COSH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_COSH */ - {__pyx_k_TA_DEMA, sizeof(__pyx_k_TA_DEMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_DEMA */ - {__pyx_k_TA_DIV, sizeof(__pyx_k_TA_DIV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_DIV */ - {__pyx_k_TA_DX, sizeof(__pyx_k_TA_DX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_DX */ - {__pyx_k_TA_EMA, sizeof(__pyx_k_TA_EMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_EMA */ - {__pyx_k_TA_EXP, sizeof(__pyx_k_TA_EXP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_EXP */ - {__pyx_k_TA_FLOOR, sizeof(__pyx_k_TA_FLOOR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_FLOOR */ - {__pyx_k_TA_FUNCTION_NAMES, sizeof(__pyx_k_TA_FUNCTION_NAMES), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_FUNCTION_NAMES */ - {__pyx_k_TA_FUNC_FLAGS, sizeof(__pyx_k_TA_FUNC_FLAGS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_FUNC_FLAGS */ - {__pyx_k_TA_FuncTableAlloc, sizeof(__pyx_k_TA_FuncTableAlloc), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_FuncTableAlloc */ - {__pyx_k_TA_FuncTableFree, sizeof(__pyx_k_TA_FuncTableFree), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_FuncTableFree */ - {__pyx_k_TA_GetFuncHandle, sizeof(__pyx_k_TA_GetFuncHandle), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_GetFuncHandle */ - {__pyx_k_TA_GetFuncInfo, sizeof(__pyx_k_TA_GetFuncInfo), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_GetFuncInfo */ - {__pyx_k_TA_GetInputParameterInfo, sizeof(__pyx_k_TA_GetInputParameterInfo), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_GetInputParameterInfo */ - {__pyx_k_TA_GetLookback, sizeof(__pyx_k_TA_GetLookback), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_GetLookback */ - {__pyx_k_TA_GetOptInputParameterInfo, sizeof(__pyx_k_TA_GetOptInputParameterInfo), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_GetOptInputParameterInfo */ - {__pyx_k_TA_GetOutputParameterInfo, sizeof(__pyx_k_TA_GetOutputParameterInfo), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_GetOutputParameterInfo */ - {__pyx_k_TA_GroupTableAlloc, sizeof(__pyx_k_TA_GroupTableAlloc), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_GroupTableAlloc */ - {__pyx_k_TA_GroupTableFree, sizeof(__pyx_k_TA_GroupTableFree), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_GroupTableFree */ - {__pyx_k_TA_HT_DCPERIOD, sizeof(__pyx_k_TA_HT_DCPERIOD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_HT_DCPERIOD */ - {__pyx_k_TA_HT_DCPHASE, sizeof(__pyx_k_TA_HT_DCPHASE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_HT_DCPHASE */ - {__pyx_k_TA_HT_PHASOR, sizeof(__pyx_k_TA_HT_PHASOR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_HT_PHASOR */ - {__pyx_k_TA_HT_SINE, sizeof(__pyx_k_TA_HT_SINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_HT_SINE */ - {__pyx_k_TA_HT_TRENDLINE, sizeof(__pyx_k_TA_HT_TRENDLINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_HT_TRENDLINE */ - {__pyx_k_TA_HT_TRENDMODE, sizeof(__pyx_k_TA_HT_TRENDMODE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_HT_TRENDMODE */ - {__pyx_k_TA_IMI, sizeof(__pyx_k_TA_IMI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_IMI */ - {__pyx_k_TA_INPUT_FLAGS, sizeof(__pyx_k_TA_INPUT_FLAGS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_INPUT_FLAGS */ - {__pyx_k_TA_Initialize, sizeof(__pyx_k_TA_Initialize), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_Initialize */ - {__pyx_k_TA_KAMA, sizeof(__pyx_k_TA_KAMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_KAMA */ - {__pyx_k_TA_LINEARREG, sizeof(__pyx_k_TA_LINEARREG), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_LINEARREG */ - {__pyx_k_TA_LINEARREG_ANGLE, sizeof(__pyx_k_TA_LINEARREG_ANGLE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_LINEARREG_ANGLE */ - {__pyx_k_TA_LINEARREG_INTERCEPT, sizeof(__pyx_k_TA_LINEARREG_INTERCEPT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_LINEARREG_INTERCEPT */ - {__pyx_k_TA_LINEARREG_SLOPE, sizeof(__pyx_k_TA_LINEARREG_SLOPE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_LINEARREG_SLOPE */ - {__pyx_k_TA_LN, sizeof(__pyx_k_TA_LN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_LN */ - {__pyx_k_TA_LOG10, sizeof(__pyx_k_TA_LOG10), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_LOG10 */ - {__pyx_k_TA_MA, sizeof(__pyx_k_TA_MA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MA */ - {__pyx_k_TA_MACD, sizeof(__pyx_k_TA_MACD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MACD */ - {__pyx_k_TA_MACDEXT, sizeof(__pyx_k_TA_MACDEXT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MACDEXT */ - {__pyx_k_TA_MACDFIX, sizeof(__pyx_k_TA_MACDFIX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MACDFIX */ - {__pyx_k_TA_MAMA, sizeof(__pyx_k_TA_MAMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MAMA */ - {__pyx_k_TA_MAVP, sizeof(__pyx_k_TA_MAVP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MAVP */ - {__pyx_k_TA_MAX, sizeof(__pyx_k_TA_MAX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MAX */ - {__pyx_k_TA_MAXINDEX, sizeof(__pyx_k_TA_MAXINDEX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MAXINDEX */ - {__pyx_k_TA_MEDPRICE, sizeof(__pyx_k_TA_MEDPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MEDPRICE */ - {__pyx_k_TA_MFI, sizeof(__pyx_k_TA_MFI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MFI */ - {__pyx_k_TA_MIDPOINT, sizeof(__pyx_k_TA_MIDPOINT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MIDPOINT */ - {__pyx_k_TA_MIDPRICE, sizeof(__pyx_k_TA_MIDPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MIDPRICE */ - {__pyx_k_TA_MIN, sizeof(__pyx_k_TA_MIN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MIN */ - {__pyx_k_TA_MININDEX, sizeof(__pyx_k_TA_MININDEX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MININDEX */ - {__pyx_k_TA_MINMAX, sizeof(__pyx_k_TA_MINMAX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MINMAX */ - {__pyx_k_TA_MINMAXINDEX, sizeof(__pyx_k_TA_MINMAXINDEX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MINMAXINDEX */ - {__pyx_k_TA_MINUS_DI, sizeof(__pyx_k_TA_MINUS_DI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MINUS_DI */ - {__pyx_k_TA_MINUS_DM, sizeof(__pyx_k_TA_MINUS_DM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MINUS_DM */ - {__pyx_k_TA_MOM, sizeof(__pyx_k_TA_MOM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MOM */ - {__pyx_k_TA_MULT, sizeof(__pyx_k_TA_MULT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MULT */ - {__pyx_k_TA_NATR, sizeof(__pyx_k_TA_NATR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_NATR */ - {__pyx_k_TA_OBV, sizeof(__pyx_k_TA_OBV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_OBV */ - {__pyx_k_TA_OUTPUT_FLAGS, sizeof(__pyx_k_TA_OUTPUT_FLAGS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_OUTPUT_FLAGS */ - {__pyx_k_TA_PLUS_DI, sizeof(__pyx_k_TA_PLUS_DI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_PLUS_DI */ - {__pyx_k_TA_PLUS_DM, sizeof(__pyx_k_TA_PLUS_DM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_PLUS_DM */ - {__pyx_k_TA_PPO, sizeof(__pyx_k_TA_PPO), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_PPO */ - {__pyx_k_TA_ParamHolderAlloc, sizeof(__pyx_k_TA_ParamHolderAlloc), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ParamHolderAlloc */ - {__pyx_k_TA_ParamHolderFree, sizeof(__pyx_k_TA_ParamHolderFree), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ParamHolderFree */ - {__pyx_k_TA_ROC, sizeof(__pyx_k_TA_ROC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ROC */ - {__pyx_k_TA_ROCP, sizeof(__pyx_k_TA_ROCP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ROCP */ - {__pyx_k_TA_ROCR, sizeof(__pyx_k_TA_ROCR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ROCR */ - {__pyx_k_TA_ROCR100, sizeof(__pyx_k_TA_ROCR100), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ROCR100 */ - {__pyx_k_TA_RSI, sizeof(__pyx_k_TA_RSI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_RSI */ - {__pyx_k_TA_RestoreCandleDefaultSettings, sizeof(__pyx_k_TA_RestoreCandleDefaultSettings), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_RestoreCandleDefaultSettings */ - {__pyx_k_TA_SAR, sizeof(__pyx_k_TA_SAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SAR */ - {__pyx_k_TA_SAREXT, sizeof(__pyx_k_TA_SAREXT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SAREXT */ - {__pyx_k_TA_SIN, sizeof(__pyx_k_TA_SIN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SIN */ - {__pyx_k_TA_SINH, sizeof(__pyx_k_TA_SINH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SINH */ - {__pyx_k_TA_SMA, sizeof(__pyx_k_TA_SMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SMA */ - {__pyx_k_TA_SQRT, sizeof(__pyx_k_TA_SQRT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SQRT */ - {__pyx_k_TA_STDDEV, sizeof(__pyx_k_TA_STDDEV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_STDDEV */ - {__pyx_k_TA_STOCH, sizeof(__pyx_k_TA_STOCH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_STOCH */ - {__pyx_k_TA_STOCHF, sizeof(__pyx_k_TA_STOCHF), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_STOCHF */ - {__pyx_k_TA_STOCHRSI, sizeof(__pyx_k_TA_STOCHRSI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_STOCHRSI */ - {__pyx_k_TA_SUB, sizeof(__pyx_k_TA_SUB), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SUB */ - {__pyx_k_TA_SUM, sizeof(__pyx_k_TA_SUM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SUM */ - {__pyx_k_TA_SetCandleSettings, sizeof(__pyx_k_TA_SetCandleSettings), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SetCandleSettings */ - {__pyx_k_TA_SetCompatibility, sizeof(__pyx_k_TA_SetCompatibility), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SetCompatibility */ - {__pyx_k_TA_SetOptInputParamInteger, sizeof(__pyx_k_TA_SetOptInputParamInteger), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SetOptInputParamInteger */ - {__pyx_k_TA_SetOptInputParamReal, sizeof(__pyx_k_TA_SetOptInputParamReal), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SetOptInputParamReal */ - {__pyx_k_TA_SetUnstablePeriod, sizeof(__pyx_k_TA_SetUnstablePeriod), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SetUnstablePeriod */ - {__pyx_k_TA_Shutdown, sizeof(__pyx_k_TA_Shutdown), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_Shutdown */ - {__pyx_k_TA_T3, sizeof(__pyx_k_TA_T3), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_T3 */ - {__pyx_k_TA_TAN, sizeof(__pyx_k_TA_TAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_TAN */ - {__pyx_k_TA_TANH, sizeof(__pyx_k_TA_TANH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_TANH */ - {__pyx_k_TA_TEMA, sizeof(__pyx_k_TA_TEMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_TEMA */ - {__pyx_k_TA_TRANGE, sizeof(__pyx_k_TA_TRANGE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_TRANGE */ - {__pyx_k_TA_TRIMA, sizeof(__pyx_k_TA_TRIMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_TRIMA */ - {__pyx_k_TA_TRIX, sizeof(__pyx_k_TA_TRIX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_TRIX */ - {__pyx_k_TA_TSF, sizeof(__pyx_k_TA_TSF), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_TSF */ - {__pyx_k_TA_TYPPRICE, sizeof(__pyx_k_TA_TYPPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_TYPPRICE */ - {__pyx_k_TA_ULTOSC, sizeof(__pyx_k_TA_ULTOSC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ULTOSC */ - {__pyx_k_TA_VAR, sizeof(__pyx_k_TA_VAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_VAR */ - {__pyx_k_TA_WCLPRICE, sizeof(__pyx_k_TA_WCLPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_WCLPRICE */ - {__pyx_k_TA_WILLR, sizeof(__pyx_k_TA_WILLR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_WILLR */ - {__pyx_k_TA_WMA, sizeof(__pyx_k_TA_WMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_WMA */ - {__pyx_k_TEMA, sizeof(__pyx_k_TEMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TEMA */ - {__pyx_k_TRANGE, sizeof(__pyx_k_TRANGE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TRANGE */ - {__pyx_k_TRIMA, sizeof(__pyx_k_TRIMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TRIMA */ - {__pyx_k_TRIX, sizeof(__pyx_k_TRIX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TRIX */ - {__pyx_k_TSF, sizeof(__pyx_k_TSF), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TSF */ - {__pyx_k_TYPPRICE, sizeof(__pyx_k_TYPPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TYPPRICE */ - {__pyx_k_This_is_a_pythonic_wrapper_arou, sizeof(__pyx_k_This_is_a_pythonic_wrapper_arou), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_This_is_a_pythonic_wrapper_arou */ - {__pyx_k_Too_many_price_arguments_expecte, sizeof(__pyx_k_Too_many_price_arguments_expecte), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Too_many_price_arguments_expecte */ - {__pyx_k_Triangular_Moving_Average, sizeof(__pyx_k_Triangular_Moving_Average), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Triangular_Moving_Average */ - {__pyx_k_Triple_Exponential_Moving_Averag, sizeof(__pyx_k_Triple_Exponential_Moving_Averag), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Triple_Exponential_Moving_Averag */ - {__pyx_k_Triple_Generalized_Double_Expone, sizeof(__pyx_k_Triple_Generalized_Double_Expone), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Triple_Generalized_Double_Expone */ - {__pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TypeError */ - {__pyx_k_ULTOSC, sizeof(__pyx_k_ULTOSC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ULTOSC */ - {__pyx_k_Unknown_Error, sizeof(__pyx_k_Unknown_Error), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Unknown_Error */ - {__pyx_k_Unknown_Error_TA_UNKNOWN_ERR, sizeof(__pyx_k_Unknown_Error_TA_UNKNOWN_ERR), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Unknown_Error_TA_UNKNOWN_ERR */ - {__pyx_k_VAR, sizeof(__pyx_k_VAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_VAR */ - {__pyx_k_Values_represent_a_lower_limit, sizeof(__pyx_k_Values_represent_a_lower_limit), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Values_represent_a_lower_limit */ - {__pyx_k_Values_represent_an_upper_limit, sizeof(__pyx_k_Values_represent_an_upper_limit), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Values_represent_an_upper_limit */ - {__pyx_k_WCLPRICE, sizeof(__pyx_k_WCLPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_WCLPRICE */ - {__pyx_k_WILLR, sizeof(__pyx_k_WILLR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_WILLR */ - {__pyx_k_WMA, sizeof(__pyx_k_WMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_WMA */ - {__pyx_k_Weighted_Moving_Average, sizeof(__pyx_k_Weighted_Moving_Average), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Weighted_Moving_Average */ - {__pyx_k__10, sizeof(__pyx_k__10), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__10 */ - {__pyx_k__11, sizeof(__pyx_k__11), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__11 */ - {__pyx_k__12, sizeof(__pyx_k__12), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__12 */ - {__pyx_k__13, sizeof(__pyx_k__13), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__13 */ - {__pyx_k__14, sizeof(__pyx_k__14), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__14 */ - {__pyx_k__15, sizeof(__pyx_k__15), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__15 */ - {__pyx_k__2, sizeof(__pyx_k__2), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__2 */ - {__pyx_k__3, sizeof(__pyx_k__3), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__3 */ - {__pyx_k__4, sizeof(__pyx_k__4), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__4 */ - {__pyx_k__5, sizeof(__pyx_k__5), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__5 */ - {__pyx_k__6, sizeof(__pyx_k__6), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__6 */ - {__pyx_k__7, sizeof(__pyx_k__7), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__7 */ - {__pyx_k__8, sizeof(__pyx_k__8), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__8 */ - {__pyx_k__9, sizeof(__pyx_k__9), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__9 */ - {__pyx_k_acceleration, sizeof(__pyx_k_acceleration), 0, 1, 1}, /* PyObject cname: __pyx_n_u_acceleration */ - {__pyx_k_accelerationinitlong, sizeof(__pyx_k_accelerationinitlong), 0, 1, 1}, /* PyObject cname: __pyx_n_u_accelerationinitlong */ - {__pyx_k_accelerationinitshort, sizeof(__pyx_k_accelerationinitshort), 0, 1, 1}, /* PyObject cname: __pyx_n_u_accelerationinitshort */ - {__pyx_k_accelerationlong, sizeof(__pyx_k_accelerationlong), 0, 1, 1}, /* PyObject cname: __pyx_n_u_accelerationlong */ - {__pyx_k_accelerationmaxlong, sizeof(__pyx_k_accelerationmaxlong), 0, 1, 1}, /* PyObject cname: __pyx_n_u_accelerationmaxlong */ - {__pyx_k_accelerationmaxshort, sizeof(__pyx_k_accelerationmaxshort), 0, 1, 1}, /* PyObject cname: __pyx_n_u_accelerationmaxshort */ - {__pyx_k_accelerationshort, sizeof(__pyx_k_accelerationshort), 0, 1, 1}, /* PyObject cname: __pyx_n_u_accelerationshort */ - {__pyx_k_add_note, sizeof(__pyx_k_add_note), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_add_note */ - {__pyx_k_all, sizeof(__pyx_k_all), 0, 1, 1}, /* PyObject cname: __pyx_n_u_all */ - {__pyx_k_any_ndarray, sizeof(__pyx_k_any_ndarray), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_any_ndarray */ - {__pyx_k_append, sizeof(__pyx_k_append), 0, 1, 1}, /* PyObject cname: __pyx_n_u_append */ - {__pyx_k_arg, sizeof(__pyx_k_arg), 0, 1, 1}, /* PyObject cname: __pyx_n_u_arg */ - {__pyx_k_args, sizeof(__pyx_k_args), 0, 1, 1}, /* PyObject cname: __pyx_n_u_args */ - {__pyx_k_ascii, sizeof(__pyx_k_ascii), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ascii */ - {__pyx_k_astype, sizeof(__pyx_k_astype), 0, 1, 1}, /* PyObject cname: __pyx_n_u_astype */ - {__pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 1, 1}, /* PyObject cname: __pyx_n_u_asyncio_coroutines */ - {__pyx_k_avgperiod, sizeof(__pyx_k_avgperiod), 0, 1, 1}, /* PyObject cname: __pyx_n_u_avgperiod */ - {__pyx_k_b, sizeof(__pyx_k_b), 0, 1, 1}, /* PyObject cname: __pyx_n_u_b */ - {__pyx_k_begidx, sizeof(__pyx_k_begidx), 0, 1, 1}, /* PyObject cname: __pyx_n_u_begidx */ - {__pyx_k_bytes2str, sizeof(__pyx_k_bytes2str), 0, 1, 1}, /* PyObject cname: __pyx_n_u_bytes2str */ - {__pyx_k_call, sizeof(__pyx_k_call), 0, 1, 1}, /* PyObject cname: __pyx_n_u_call */ - {__pyx_k_call_function, sizeof(__pyx_k_call_function), 0, 1, 1}, /* PyObject cname: __pyx_n_u_call_function */ - {__pyx_k_check_opt_input_value, sizeof(__pyx_k_check_opt_input_value), 0, 1, 1}, /* PyObject cname: __pyx_n_u_check_opt_input_value */ - {__pyx_k_class_getitem, sizeof(__pyx_k_class_getitem), 0, 1, 1}, /* PyObject cname: __pyx_n_u_class_getitem */ - {__pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 1, 1}, /* PyObject cname: __pyx_n_u_cline_in_traceback */ - {__pyx_k_clone, sizeof(__pyx_k_clone), 0, 1, 1}, /* PyObject cname: __pyx_n_u_clone */ - {__pyx_k_close, sizeof(__pyx_k_close), 0, 1, 1}, /* PyObject cname: __pyx_n_u_close */ - {__pyx_k_close_data, sizeof(__pyx_k_close_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_close_data */ - {__pyx_k_collections, sizeof(__pyx_k_collections), 0, 1, 1}, /* PyObject cname: __pyx_n_u_collections */ - {__pyx_k_column_stack, sizeof(__pyx_k_column_stack), 0, 1, 1}, /* PyObject cname: __pyx_n_u_column_stack */ - {__pyx_k_columns, sizeof(__pyx_k_columns), 0, 1, 1}, /* PyObject cname: __pyx_n_u_columns */ - {__pyx_k_copy, sizeof(__pyx_k_copy), 0, 1, 1}, /* PyObject cname: __pyx_n_u_copy */ - {__pyx_k_d, sizeof(__pyx_k_d), 0, 1, 1}, /* PyObject cname: __pyx_n_u_d */ - {__pyx_k_decode, sizeof(__pyx_k_decode), 0, 1, 1}, /* PyObject cname: __pyx_n_u_decode */ - {__pyx_k_default_value, sizeof(__pyx_k_default_value), 0, 1, 1}, /* PyObject cname: __pyx_n_u_default_value */ - {__pyx_k_defaults, sizeof(__pyx_k_defaults), 0, 1, 1}, /* PyObject cname: __pyx_n_u_defaults */ - {__pyx_k_display_name, sizeof(__pyx_k_display_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_display_name */ - {__pyx_k_display_name_s_group_s, sizeof(__pyx_k_display_name_s_group_s), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_display_name_s_group_s */ - {__pyx_k_doc, sizeof(__pyx_k_doc), 0, 1, 1}, /* PyObject cname: __pyx_n_u_doc */ - {__pyx_k_docs, sizeof(__pyx_k_docs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_docs */ - {__pyx_k_documentation, sizeof(__pyx_k_documentation), 0, 1, 1}, /* PyObject cname: __pyx_n_u_documentation */ - {__pyx_k_empty, sizeof(__pyx_k_empty), 0, 1, 1}, /* PyObject cname: __pyx_n_u_empty */ - {__pyx_k_endidx, sizeof(__pyx_k_endidx), 0, 1, 1}, /* PyObject cname: __pyx_n_u_endidx */ - {__pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 1, 1}, /* PyObject cname: __pyx_n_u_enumerate */ - {__pyx_k_expected, sizeof(__pyx_k_expected), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_expected */ - {__pyx_k_factor, sizeof(__pyx_k_factor), 0, 1, 1}, /* PyObject cname: __pyx_n_u_factor */ - {__pyx_k_fastd_matype, sizeof(__pyx_k_fastd_matype), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fastd_matype */ - {__pyx_k_fastd_period, sizeof(__pyx_k_fastd_period), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fastd_period */ - {__pyx_k_fastk_period, sizeof(__pyx_k_fastk_period), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fastk_period */ - {__pyx_k_fastlimit, sizeof(__pyx_k_fastlimit), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fastlimit */ - {__pyx_k_fastmatype, sizeof(__pyx_k_fastmatype), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fastmatype */ - {__pyx_k_fastperiod, sizeof(__pyx_k_fastperiod), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fastperiod */ - {__pyx_k_flag, sizeof(__pyx_k_flag), 0, 1, 1}, /* PyObject cname: __pyx_n_u_flag */ - {__pyx_k_flags, sizeof(__pyx_k_flags), 0, 1, 1}, /* PyObject cname: __pyx_n_u_flags */ - {__pyx_k_flags_lookup_dict, sizeof(__pyx_k_flags_lookup_dict), 0, 1, 1}, /* PyObject cname: __pyx_n_u_flags_lookup_dict */ - {__pyx_k_func, sizeof(__pyx_k_func), 0, 1, 1}, /* PyObject cname: __pyx_n_u_func */ - {__pyx_k_func_args, sizeof(__pyx_k_func_args), 0, 1, 1}, /* PyObject cname: __pyx_n_u_func_args */ - {__pyx_k_func_info, sizeof(__pyx_k_func_info), 0, 1, 1}, /* PyObject cname: __pyx_n_u_func_info */ - {__pyx_k_func_line, sizeof(__pyx_k_func_line), 0, 1, 1}, /* PyObject cname: __pyx_n_u_func_line */ - {__pyx_k_func_object, sizeof(__pyx_k_func_object), 0, 1, 1}, /* PyObject cname: __pyx_n_u_func_object */ - {__pyx_k_function_failed_with_error_code, sizeof(__pyx_k_function_failed_with_error_code), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_function_failed_with_error_code */ - {__pyx_k_function_flags, sizeof(__pyx_k_function_flags), 0, 1, 1}, /* PyObject cname: __pyx_n_u_function_flags */ - {__pyx_k_function_name, sizeof(__pyx_k_function_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_function_name */ - {__pyx_k_functions, sizeof(__pyx_k_functions), 0, 1, 1}, /* PyObject cname: __pyx_n_u_functions */ - {__pyx_k_get_defaults_and_docs, sizeof(__pyx_k_get_defaults_and_docs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get_defaults_and_docs */ - {__pyx_k_get_flags, sizeof(__pyx_k_get_flags), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get_flags */ - {__pyx_k_get_input_arrays, sizeof(__pyx_k_get_input_arrays), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get_input_arrays */ - {__pyx_k_get_input_names, sizeof(__pyx_k_get_input_names), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get_input_names */ - {__pyx_k_get_opt_input_value, sizeof(__pyx_k_get_opt_input_value), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get_opt_input_value */ - {__pyx_k_get_parameters, sizeof(__pyx_k_get_parameters), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get_parameters */ - {__pyx_k_getitem, sizeof(__pyx_k_getitem), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getitem */ - {__pyx_k_got, sizeof(__pyx_k_got), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_got */ - {__pyx_k_group, sizeof(__pyx_k_group), 0, 1, 1}, /* PyObject cname: __pyx_n_u_group */ - {__pyx_k_groups, sizeof(__pyx_k_groups), 0, 1, 1}, /* PyObject cname: __pyx_n_u_groups */ - {__pyx_k_help, sizeof(__pyx_k_help), 0, 1, 1}, /* PyObject cname: __pyx_n_u_help */ - {__pyx_k_high, sizeof(__pyx_k_high), 0, 1, 1}, /* PyObject cname: __pyx_n_u_high */ - {__pyx_k_high_data, sizeof(__pyx_k_high_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_high_data */ - {__pyx_k_holder, sizeof(__pyx_k_holder), 0, 1, 1}, /* PyObject cname: __pyx_n_u_holder */ - {__pyx_k_i, sizeof(__pyx_k_i), 0, 1, 1}, /* PyObject cname: __pyx_n_u_i */ - {__pyx_k_id, sizeof(__pyx_k_id), 0, 1, 1}, /* PyObject cname: __pyx_n_u_id */ - {__pyx_k_idx, sizeof(__pyx_k_idx), 0, 1, 1}, /* PyObject cname: __pyx_n_u_idx */ - {__pyx_k_import_error, sizeof(__pyx_k_import_error), 0, 1, 1}, /* PyObject cname: __pyx_n_u_import_error */ - {__pyx_k_in, sizeof(__pyx_k_in), 0, 1, 1}, /* PyObject cname: __pyx_n_u_in */ - {__pyx_k_index, sizeof(__pyx_k_index), 0, 1, 1}, /* PyObject cname: __pyx_n_u_index */ - {__pyx_k_info, sizeof(__pyx_k_info), 0, 1, 1}, /* PyObject cname: __pyx_n_u_info */ - {__pyx_k_init, sizeof(__pyx_k_init), 0, 1, 1}, /* PyObject cname: __pyx_n_u_init */ - {__pyx_k_initializing, sizeof(__pyx_k_initializing), 0, 1, 1}, /* PyObject cname: __pyx_n_u_initializing */ - {__pyx_k_input_array_has_wrong_dimensions, sizeof(__pyx_k_input_array_has_wrong_dimensions), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_input_array_has_wrong_dimensions */ - {__pyx_k_input_array_lengths_are_differen, sizeof(__pyx_k_input_array_lengths_are_differen), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_input_array_lengths_are_differen */ - {__pyx_k_input_array_type_is_not_double, sizeof(__pyx_k_input_array_type_is_not_double), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_input_array_type_is_not_double */ - {__pyx_k_input_arrays, sizeof(__pyx_k_input_arrays), 0, 1, 1}, /* PyObject cname: __pyx_n_u_input_arrays */ - {__pyx_k_input_arrays_2, sizeof(__pyx_k_input_arrays_2), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_input_arrays_2 */ - {__pyx_k_input_arrays_parameter_missing_r, sizeof(__pyx_k_input_arrays_parameter_missing_r), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_input_arrays_parameter_missing_r */ - {__pyx_k_input_name, sizeof(__pyx_k_input_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_input_name */ - {__pyx_k_input_names, sizeof(__pyx_k_input_names), 0, 1, 1}, /* PyObject cname: __pyx_n_u_input_names */ - {__pyx_k_input_price_series_names, sizeof(__pyx_k_input_price_series_names), 0, 1, 1}, /* PyObject cname: __pyx_n_u_input_price_series_names */ - {__pyx_k_input_price_series_names_2, sizeof(__pyx_k_input_price_series_names_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_input_price_series_names_2 */ - {__pyx_k_integer, sizeof(__pyx_k_integer), 0, 1, 1}, /* PyObject cname: __pyx_n_u_integer */ - {__pyx_k_integer_values_are_100_0_or_100, sizeof(__pyx_k_integer_values_are_100_0_or_100), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_integer_values_are_100_0_or_100 */ - {__pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 1, 1}, /* PyObject cname: __pyx_n_u_is_coroutine */ - {__pyx_k_is_empty, sizeof(__pyx_k_is_empty), 0, 1, 1}, /* PyObject cname: __pyx_n_u_is_empty */ - {__pyx_k_items, sizeof(__pyx_k_items), 0, 1, 1}, /* PyObject cname: __pyx_n_u_items */ - {__pyx_k_key, sizeof(__pyx_k_key), 0, 1, 1}, /* PyObject cname: __pyx_n_u_key */ - {__pyx_k_keys, sizeof(__pyx_k_keys), 0, 1, 1}, /* PyObject cname: __pyx_n_u_keys */ - {__pyx_k_kwargs, sizeof(__pyx_k_kwargs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_kwargs */ - {__pyx_k_length, sizeof(__pyx_k_length), 0, 1, 1}, /* PyObject cname: __pyx_n_u_length */ - {__pyx_k_local, sizeof(__pyx_k_local), 0, 1, 1}, /* PyObject cname: __pyx_n_u_local */ - {__pyx_k_local_2, sizeof(__pyx_k_local_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_local_2 */ - {__pyx_k_log, sizeof(__pyx_k_log), 0, 1, 1}, /* PyObject cname: __pyx_n_u_log */ - {__pyx_k_lookback, sizeof(__pyx_k_lookback), 0, 1, 1}, /* PyObject cname: __pyx_n_u_lookback */ - {__pyx_k_lookup, sizeof(__pyx_k_lookup), 0, 1, 1}, /* PyObject cname: __pyx_n_u_lookup */ - {__pyx_k_low, sizeof(__pyx_k_low), 0, 1, 1}, /* PyObject cname: __pyx_n_u_low */ - {__pyx_k_low_data, sizeof(__pyx_k_low_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_low_data */ - {__pyx_k_lower, sizeof(__pyx_k_lower), 0, 1, 1}, /* PyObject cname: __pyx_n_u_lower */ - {__pyx_k_main, sizeof(__pyx_k_main), 0, 1, 1}, /* PyObject cname: __pyx_n_u_main */ - {__pyx_k_math, sizeof(__pyx_k_math), 0, 1, 1}, /* PyObject cname: __pyx_n_u_math */ - {__pyx_k_matype, sizeof(__pyx_k_matype), 0, 1, 1}, /* PyObject cname: __pyx_n_u_matype */ - {__pyx_k_max, sizeof(__pyx_k_max), 0, 1, 1}, /* PyObject cname: __pyx_n_u_max */ - {__pyx_k_max_int, sizeof(__pyx_k_max_int), 0, 1, 1}, /* PyObject cname: __pyx_n_u_max_int */ - {__pyx_k_maximum, sizeof(__pyx_k_maximum), 0, 1, 1}, /* PyObject cname: __pyx_n_u_maximum */ - {__pyx_k_maxperiod, sizeof(__pyx_k_maxperiod), 0, 1, 1}, /* PyObject cname: __pyx_n_u_maxperiod */ - {__pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 1, 1}, /* PyObject cname: __pyx_n_u_metaclass */ - {__pyx_k_min, sizeof(__pyx_k_min), 0, 1, 1}, /* PyObject cname: __pyx_n_u_min */ - {__pyx_k_min_int, sizeof(__pyx_k_min_int), 0, 1, 1}, /* PyObject cname: __pyx_n_u_min_int */ - {__pyx_k_minperiod, sizeof(__pyx_k_minperiod), 0, 1, 1}, /* PyObject cname: __pyx_n_u_minperiod */ - {__pyx_k_missing, sizeof(__pyx_k_missing), 0, 1, 1}, /* PyObject cname: __pyx_n_u_missing */ - {__pyx_k_missing_keys, sizeof(__pyx_k_missing_keys), 0, 1, 1}, /* PyObject cname: __pyx_n_u_missing_keys */ - {__pyx_k_module, sizeof(__pyx_k_module), 0, 1, 1}, /* PyObject cname: __pyx_n_u_module */ - {__pyx_k_mro_entries, sizeof(__pyx_k_mro_entries), 0, 1, 1}, /* PyObject cname: __pyx_n_u_mro_entries */ - {__pyx_k_msg, sizeof(__pyx_k_msg), 0, 1, 1}, /* PyObject cname: __pyx_n_u_msg */ - {__pyx_k_n, sizeof(__pyx_k_n), 0, 1, 1}, /* PyObject cname: __pyx_n_u_n */ - {__pyx_k_name, sizeof(__pyx_k_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_name */ - {__pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_name_2 */ - {__pyx_k_nan, sizeof(__pyx_k_nan), 0, 1, 1}, /* PyObject cname: __pyx_n_u_nan */ - {__pyx_k_nbdev, sizeof(__pyx_k_nbdev), 0, 1, 1}, /* PyObject cname: __pyx_n_u_nbdev */ - {__pyx_k_nbdevdn, sizeof(__pyx_k_nbdevdn), 0, 1, 1}, /* PyObject cname: __pyx_n_u_nbdevdn */ - {__pyx_k_nbdevup, sizeof(__pyx_k_nbdevup), 0, 1, 1}, /* PyObject cname: __pyx_n_u_nbdevup */ - {__pyx_k_no_existing_input_arrays, sizeof(__pyx_k_no_existing_input_arrays), 0, 1, 1}, /* PyObject cname: __pyx_n_u_no_existing_input_arrays */ - {__pyx_k_num_inputs, sizeof(__pyx_k_num_inputs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_num_inputs */ - {__pyx_k_num_opt_inputs, sizeof(__pyx_k_num_opt_inputs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_num_opt_inputs */ - {__pyx_k_num_outputs, sizeof(__pyx_k_num_outputs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_num_outputs */ - {__pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 1, 1}, /* PyObject cname: __pyx_n_u_numpy */ - {__pyx_k_numpy__core_multiarray_failed_to, sizeof(__pyx_k_numpy__core_multiarray_failed_to), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_numpy__core_multiarray_failed_to */ - {__pyx_k_numpy__core_umath_failed_to_impo, sizeof(__pyx_k_numpy__core_umath_failed_to_impo), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_numpy__core_umath_failed_to_impo */ - {__pyx_k_object, sizeof(__pyx_k_object), 0, 1, 1}, /* PyObject cname: __pyx_n_u_object */ - {__pyx_k_offsetonreverse, sizeof(__pyx_k_offsetonreverse), 0, 1, 1}, /* PyObject cname: __pyx_n_u_offsetonreverse */ - {__pyx_k_open, sizeof(__pyx_k_open), 0, 1, 1}, /* PyObject cname: __pyx_n_u_open */ - {__pyx_k_openInterest, sizeof(__pyx_k_openInterest), 0, 1, 1}, /* PyObject cname: __pyx_n_u_openInterest */ - {__pyx_k_open_data, sizeof(__pyx_k_open_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_open_data */ - {__pyx_k_optIn, sizeof(__pyx_k_optIn), 0, 1, 1}, /* PyObject cname: __pyx_n_u_optIn */ - {__pyx_k_opt_input, sizeof(__pyx_k_opt_input), 0, 1, 1}, /* PyObject cname: __pyx_n_u_opt_input */ - {__pyx_k_opt_input_values, sizeof(__pyx_k_opt_input_values), 0, 1, 1}, /* PyObject cname: __pyx_n_u_opt_input_values */ - {__pyx_k_opt_inputs, sizeof(__pyx_k_opt_inputs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_opt_inputs */ - {__pyx_k_ordereddict, sizeof(__pyx_k_ordereddict), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ordereddict */ - {__pyx_k_out, sizeof(__pyx_k_out), 0, 1, 1}, /* PyObject cname: __pyx_n_u_out */ - {__pyx_k_outaroondown, sizeof(__pyx_k_outaroondown), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outaroondown */ - {__pyx_k_outaroonup, sizeof(__pyx_k_outaroonup), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outaroonup */ - {__pyx_k_outbegidx, sizeof(__pyx_k_outbegidx), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outbegidx */ - {__pyx_k_outfama, sizeof(__pyx_k_outfama), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outfama */ - {__pyx_k_outfastd, sizeof(__pyx_k_outfastd), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outfastd */ - {__pyx_k_outfastk, sizeof(__pyx_k_outfastk), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outfastk */ - {__pyx_k_outinphase, sizeof(__pyx_k_outinphase), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outinphase */ - {__pyx_k_outinteger, sizeof(__pyx_k_outinteger), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outinteger */ - {__pyx_k_outinteger_data, sizeof(__pyx_k_outinteger_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outinteger_data */ - {__pyx_k_outleadsine, sizeof(__pyx_k_outleadsine), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outleadsine */ - {__pyx_k_outmacd, sizeof(__pyx_k_outmacd), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outmacd */ - {__pyx_k_outmacdhist, sizeof(__pyx_k_outmacdhist), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outmacdhist */ - {__pyx_k_outmacdsignal, sizeof(__pyx_k_outmacdsignal), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outmacdsignal */ - {__pyx_k_outmama, sizeof(__pyx_k_outmama), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outmama */ - {__pyx_k_outmax, sizeof(__pyx_k_outmax), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outmax */ - {__pyx_k_outmaxidx, sizeof(__pyx_k_outmaxidx), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outmaxidx */ - {__pyx_k_outmaxidx_data, sizeof(__pyx_k_outmaxidx_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outmaxidx_data */ - {__pyx_k_outmin, sizeof(__pyx_k_outmin), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outmin */ - {__pyx_k_outminidx, sizeof(__pyx_k_outminidx), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outminidx */ - {__pyx_k_outminidx_data, sizeof(__pyx_k_outminidx_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outminidx_data */ - {__pyx_k_outnbelement, sizeof(__pyx_k_outnbelement), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outnbelement */ - {__pyx_k_output, sizeof(__pyx_k_output), 0, 1, 1}, /* PyObject cname: __pyx_n_u_output */ - {__pyx_k_output_flags, sizeof(__pyx_k_output_flags), 0, 1, 1}, /* PyObject cname: __pyx_n_u_output_flags */ - {__pyx_k_output_name, sizeof(__pyx_k_output_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_output_name */ - {__pyx_k_output_names, sizeof(__pyx_k_output_names), 0, 1, 1}, /* PyObject cname: __pyx_n_u_output_names */ - {__pyx_k_outputs, sizeof(__pyx_k_outputs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outputs */ - {__pyx_k_outputs_valid, sizeof(__pyx_k_outputs_valid), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outputs_valid */ - {__pyx_k_outquadrature, sizeof(__pyx_k_outquadrature), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outquadrature */ - {__pyx_k_outreal, sizeof(__pyx_k_outreal), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outreal */ - {__pyx_k_outreallowerband, sizeof(__pyx_k_outreallowerband), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outreallowerband */ - {__pyx_k_outrealmiddleband, sizeof(__pyx_k_outrealmiddleband), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outrealmiddleband */ - {__pyx_k_outrealupperband, sizeof(__pyx_k_outrealupperband), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outrealupperband */ - {__pyx_k_outsine, sizeof(__pyx_k_outsine), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outsine */ - {__pyx_k_outslowd, sizeof(__pyx_k_outslowd), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outslowd */ - {__pyx_k_outslowk, sizeof(__pyx_k_outslowk), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outslowk */ - {__pyx_k_pandas, sizeof(__pyx_k_pandas), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pandas */ - {__pyx_k_param, sizeof(__pyx_k_param), 0, 1, 1}, /* PyObject cname: __pyx_n_u_param */ - {__pyx_k_param_name, sizeof(__pyx_k_param_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_param_name */ - {__pyx_k_parameters, sizeof(__pyx_k_parameters), 0, 1, 1}, /* PyObject cname: __pyx_n_u_parameters */ - {__pyx_k_params, sizeof(__pyx_k_params), 0, 1, 1}, /* PyObject cname: __pyx_n_u_params */ - {__pyx_k_penetration, sizeof(__pyx_k_penetration), 0, 1, 1}, /* PyObject cname: __pyx_n_u_penetration */ - {__pyx_k_period, sizeof(__pyx_k_period), 0, 1, 1}, /* PyObject cname: __pyx_n_u_period */ - {__pyx_k_periods, sizeof(__pyx_k_periods), 0, 1, 1}, /* PyObject cname: __pyx_n_u_periods */ - {__pyx_k_periods_data, sizeof(__pyx_k_periods_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_periods_data */ - {__pyx_k_polars, sizeof(__pyx_k_polars), 0, 1, 1}, /* PyObject cname: __pyx_n_u_polars */ - {__pyx_k_pop, sizeof(__pyx_k_pop), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pop */ - {__pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 1, 1}, /* PyObject cname: __pyx_n_u_prepare */ - {__pyx_k_price, sizeof(__pyx_k_price), 0, 1, 1}, /* PyObject cname: __pyx_n_u_price */ - {__pyx_k_price0, sizeof(__pyx_k_price0), 0, 1, 1}, /* PyObject cname: __pyx_n_u_price0 */ - {__pyx_k_price1, sizeof(__pyx_k_price1), 0, 1, 1}, /* PyObject cname: __pyx_n_u_price1 */ - {__pyx_k_price_series, sizeof(__pyx_k_price_series), 0, 1, 1}, /* PyObject cname: __pyx_n_u_price_series */ - {__pyx_k_price_series_name_values, sizeof(__pyx_k_price_series_name_values), 0, 1, 1}, /* PyObject cname: __pyx_n_u_price_series_name_values */ - {__pyx_k_prices, sizeof(__pyx_k_prices), 0, 1, 1}, /* PyObject cname: __pyx_n_u_prices */ - {__pyx_k_property, sizeof(__pyx_k_property), 0, 1, 1}, /* PyObject cname: __pyx_n_u_property */ - {__pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 1, 1}, /* PyObject cname: __pyx_n_u_qualname */ - {__pyx_k_range, sizeof(__pyx_k_range), 0, 1, 1}, /* PyObject cname: __pyx_n_u_range */ - {__pyx_k_rangetype, sizeof(__pyx_k_rangetype), 0, 1, 1}, /* PyObject cname: __pyx_n_u_rangetype */ - {__pyx_k_real, sizeof(__pyx_k_real), 0, 1, 1}, /* PyObject cname: __pyx_n_u_real */ - {__pyx_k_real0, sizeof(__pyx_k_real0), 0, 1, 1}, /* PyObject cname: __pyx_n_u_real0 */ - {__pyx_k_real0_data, sizeof(__pyx_k_real0_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_real0_data */ - {__pyx_k_real1, sizeof(__pyx_k_real1), 0, 1, 1}, /* PyObject cname: __pyx_n_u_real1 */ - {__pyx_k_real1_data, sizeof(__pyx_k_real1_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_real1_data */ - {__pyx_k_real_data, sizeof(__pyx_k_real_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_real_data */ - {__pyx_k_replace, sizeof(__pyx_k_replace), 0, 1, 1}, /* PyObject cname: __pyx_n_u_replace */ - {__pyx_k_repr, sizeof(__pyx_k_repr), 0, 1, 1}, /* PyObject cname: __pyx_n_u_repr */ - {__pyx_k_results, sizeof(__pyx_k_results), 0, 1, 1}, /* PyObject cname: __pyx_n_u_results */ - {__pyx_k_ret, sizeof(__pyx_k_ret), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ret */ - {__pyx_k_retCode, sizeof(__pyx_k_retCode), 0, 1, 1}, /* PyObject cname: __pyx_n_u_retCode */ - {__pyx_k_ret_code, sizeof(__pyx_k_ret_code), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ret_code */ - {__pyx_k_run, sizeof(__pyx_k_run), 0, 1, 1}, /* PyObject cname: __pyx_n_u_run */ - {__pyx_k_s, sizeof(__pyx_k_s), 0, 1, 1}, /* PyObject cname: __pyx_n_u_s */ - {__pyx_k_s_2, sizeof(__pyx_k_s_2), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_s_2 */ - {__pyx_k_s_3, sizeof(__pyx_k_s_3), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_s_3 */ - {__pyx_k_s_4, sizeof(__pyx_k_s_4), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_s_4 */ - {__pyx_k_schema, sizeof(__pyx_k_schema), 0, 1, 1}, /* PyObject cname: __pyx_n_u_schema */ - {__pyx_k_self, sizeof(__pyx_k_self), 0, 1, 1}, /* PyObject cname: __pyx_n_u_self */ - {__pyx_k_series, sizeof(__pyx_k_series), 0, 1, 1}, /* PyObject cname: __pyx_n_u_series */ - {__pyx_k_set_function_args, sizeof(__pyx_k_set_function_args), 0, 1, 1}, /* PyObject cname: __pyx_n_u_set_function_args */ - {__pyx_k_set_input_arrays, sizeof(__pyx_k_set_input_arrays), 0, 1, 1}, /* PyObject cname: __pyx_n_u_set_input_arrays */ - {__pyx_k_set_input_names, sizeof(__pyx_k_set_input_names), 0, 1, 1}, /* PyObject cname: __pyx_n_u_set_input_names */ - {__pyx_k_set_parameters, sizeof(__pyx_k_set_parameters), 0, 1, 1}, /* PyObject cname: __pyx_n_u_set_parameters */ - {__pyx_k_settingtype, sizeof(__pyx_k_settingtype), 0, 1, 1}, /* PyObject cname: __pyx_n_u_settingtype */ - {__pyx_k_signalmatype, sizeof(__pyx_k_signalmatype), 0, 1, 1}, /* PyObject cname: __pyx_n_u_signalmatype */ - {__pyx_k_signalperiod, sizeof(__pyx_k_signalperiod), 0, 1, 1}, /* PyObject cname: __pyx_n_u_signalperiod */ - {__pyx_k_skip_first, sizeof(__pyx_k_skip_first), 0, 1, 1}, /* PyObject cname: __pyx_n_u_skip_first */ - {__pyx_k_slowd_matype, sizeof(__pyx_k_slowd_matype), 0, 1, 1}, /* PyObject cname: __pyx_n_u_slowd_matype */ - {__pyx_k_slowd_period, sizeof(__pyx_k_slowd_period), 0, 1, 1}, /* PyObject cname: __pyx_n_u_slowd_period */ - {__pyx_k_slowk_matype, sizeof(__pyx_k_slowk_matype), 0, 1, 1}, /* PyObject cname: __pyx_n_u_slowk_matype */ - {__pyx_k_slowk_period, sizeof(__pyx_k_slowk_period), 0, 1, 1}, /* PyObject cname: __pyx_n_u_slowk_period */ - {__pyx_k_slowlimit, sizeof(__pyx_k_slowlimit), 0, 1, 1}, /* PyObject cname: __pyx_n_u_slowlimit */ - {__pyx_k_slowmatype, sizeof(__pyx_k_slowmatype), 0, 1, 1}, /* PyObject cname: __pyx_n_u_slowmatype */ - {__pyx_k_slowperiod, sizeof(__pyx_k_slowperiod), 0, 1, 1}, /* PyObject cname: __pyx_n_u_slowperiod */ - {__pyx_k_spec, sizeof(__pyx_k_spec), 0, 1, 1}, /* PyObject cname: __pyx_n_u_spec */ - {__pyx_k_startvalue, sizeof(__pyx_k_startvalue), 0, 1, 1}, /* PyObject cname: __pyx_n_u_startvalue */ - {__pyx_k_str, sizeof(__pyx_k_str), 0, 1, 1}, /* PyObject cname: __pyx_n_u_str */ - {__pyx_k_str2bytes, sizeof(__pyx_k_str2bytes), 0, 1, 1}, /* PyObject cname: __pyx_n_u_str2bytes */ - {__pyx_k_stream_ACCBANDS, sizeof(__pyx_k_stream_ACCBANDS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ACCBANDS */ - {__pyx_k_stream_ACOS, sizeof(__pyx_k_stream_ACOS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ACOS */ - {__pyx_k_stream_AD, sizeof(__pyx_k_stream_AD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_AD */ - {__pyx_k_stream_ADD, sizeof(__pyx_k_stream_ADD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ADD */ - {__pyx_k_stream_ADOSC, sizeof(__pyx_k_stream_ADOSC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ADOSC */ - {__pyx_k_stream_ADX, sizeof(__pyx_k_stream_ADX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ADX */ - {__pyx_k_stream_ADXR, sizeof(__pyx_k_stream_ADXR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ADXR */ - {__pyx_k_stream_APO, sizeof(__pyx_k_stream_APO), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_APO */ - {__pyx_k_stream_AROON, sizeof(__pyx_k_stream_AROON), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_AROON */ - {__pyx_k_stream_AROONOSC, sizeof(__pyx_k_stream_AROONOSC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_AROONOSC */ - {__pyx_k_stream_ASIN, sizeof(__pyx_k_stream_ASIN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ASIN */ - {__pyx_k_stream_ATAN, sizeof(__pyx_k_stream_ATAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ATAN */ - {__pyx_k_stream_ATR, sizeof(__pyx_k_stream_ATR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ATR */ - {__pyx_k_stream_AVGDEV, sizeof(__pyx_k_stream_AVGDEV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_AVGDEV */ - {__pyx_k_stream_AVGPRICE, sizeof(__pyx_k_stream_AVGPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_AVGPRICE */ - {__pyx_k_stream_BBANDS, sizeof(__pyx_k_stream_BBANDS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_BBANDS */ - {__pyx_k_stream_BETA, sizeof(__pyx_k_stream_BETA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_BETA */ - {__pyx_k_stream_BOP, sizeof(__pyx_k_stream_BOP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_BOP */ - {__pyx_k_stream_CCI, sizeof(__pyx_k_stream_CCI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CCI */ - {__pyx_k_stream_CDL2CROWS, sizeof(__pyx_k_stream_CDL2CROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDL2CROWS */ - {__pyx_k_stream_CDL3BLACKCROWS, sizeof(__pyx_k_stream_CDL3BLACKCROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDL3BLACKCROWS */ - {__pyx_k_stream_CDL3INSIDE, sizeof(__pyx_k_stream_CDL3INSIDE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDL3INSIDE */ - {__pyx_k_stream_CDL3LINESTRIKE, sizeof(__pyx_k_stream_CDL3LINESTRIKE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDL3LINESTRIKE */ - {__pyx_k_stream_CDL3OUTSIDE, sizeof(__pyx_k_stream_CDL3OUTSIDE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDL3OUTSIDE */ - {__pyx_k_stream_CDL3STARSINSOUTH, sizeof(__pyx_k_stream_CDL3STARSINSOUTH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDL3STARSINSOUTH */ - {__pyx_k_stream_CDL3WHITESOLDIERS, sizeof(__pyx_k_stream_CDL3WHITESOLDIERS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDL3WHITESOLDIERS */ - {__pyx_k_stream_CDLABANDONEDBABY, sizeof(__pyx_k_stream_CDLABANDONEDBABY), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLABANDONEDBABY */ - {__pyx_k_stream_CDLADVANCEBLOCK, sizeof(__pyx_k_stream_CDLADVANCEBLOCK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLADVANCEBLOCK */ - {__pyx_k_stream_CDLBELTHOLD, sizeof(__pyx_k_stream_CDLBELTHOLD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLBELTHOLD */ - {__pyx_k_stream_CDLBREAKAWAY, sizeof(__pyx_k_stream_CDLBREAKAWAY), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLBREAKAWAY */ - {__pyx_k_stream_CDLCLOSINGMARUBOZU, sizeof(__pyx_k_stream_CDLCLOSINGMARUBOZU), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLCLOSINGMARUBOZU */ - {__pyx_k_stream_CDLCONCEALBABYSWALL, sizeof(__pyx_k_stream_CDLCONCEALBABYSWALL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLCONCEALBABYSWALL */ - {__pyx_k_stream_CDLCOUNTERATTACK, sizeof(__pyx_k_stream_CDLCOUNTERATTACK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLCOUNTERATTACK */ - {__pyx_k_stream_CDLDARKCLOUDCOVER, sizeof(__pyx_k_stream_CDLDARKCLOUDCOVER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLDARKCLOUDCOVER */ - {__pyx_k_stream_CDLDOJI, sizeof(__pyx_k_stream_CDLDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLDOJI */ - {__pyx_k_stream_CDLDOJISTAR, sizeof(__pyx_k_stream_CDLDOJISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLDOJISTAR */ - {__pyx_k_stream_CDLDRAGONFLYDOJI, sizeof(__pyx_k_stream_CDLDRAGONFLYDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLDRAGONFLYDOJI */ - {__pyx_k_stream_CDLENGULFING, sizeof(__pyx_k_stream_CDLENGULFING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLENGULFING */ - {__pyx_k_stream_CDLEVENINGDOJISTAR, sizeof(__pyx_k_stream_CDLEVENINGDOJISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLEVENINGDOJISTAR */ - {__pyx_k_stream_CDLEVENINGSTAR, sizeof(__pyx_k_stream_CDLEVENINGSTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLEVENINGSTAR */ - {__pyx_k_stream_CDLGAPSIDESIDEWHITE, sizeof(__pyx_k_stream_CDLGAPSIDESIDEWHITE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLGAPSIDESIDEWHITE */ - {__pyx_k_stream_CDLGRAVESTONEDOJI, sizeof(__pyx_k_stream_CDLGRAVESTONEDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLGRAVESTONEDOJI */ - {__pyx_k_stream_CDLHAMMER, sizeof(__pyx_k_stream_CDLHAMMER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLHAMMER */ - {__pyx_k_stream_CDLHANGINGMAN, sizeof(__pyx_k_stream_CDLHANGINGMAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLHANGINGMAN */ - {__pyx_k_stream_CDLHARAMI, sizeof(__pyx_k_stream_CDLHARAMI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLHARAMI */ - {__pyx_k_stream_CDLHARAMICROSS, sizeof(__pyx_k_stream_CDLHARAMICROSS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLHARAMICROSS */ - {__pyx_k_stream_CDLHIGHWAVE, sizeof(__pyx_k_stream_CDLHIGHWAVE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLHIGHWAVE */ - {__pyx_k_stream_CDLHIKKAKE, sizeof(__pyx_k_stream_CDLHIKKAKE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLHIKKAKE */ - {__pyx_k_stream_CDLHIKKAKEMOD, sizeof(__pyx_k_stream_CDLHIKKAKEMOD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLHIKKAKEMOD */ - {__pyx_k_stream_CDLHOMINGPIGEON, sizeof(__pyx_k_stream_CDLHOMINGPIGEON), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLHOMINGPIGEON */ - {__pyx_k_stream_CDLIDENTICAL3CROWS, sizeof(__pyx_k_stream_CDLIDENTICAL3CROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLIDENTICAL3CROWS */ - {__pyx_k_stream_CDLINNECK, sizeof(__pyx_k_stream_CDLINNECK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLINNECK */ - {__pyx_k_stream_CDLINVERTEDHAMMER, sizeof(__pyx_k_stream_CDLINVERTEDHAMMER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLINVERTEDHAMMER */ - {__pyx_k_stream_CDLKICKING, sizeof(__pyx_k_stream_CDLKICKING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLKICKING */ - {__pyx_k_stream_CDLKICKINGBYLENGTH, sizeof(__pyx_k_stream_CDLKICKINGBYLENGTH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLKICKINGBYLENGTH */ - {__pyx_k_stream_CDLLADDERBOTTOM, sizeof(__pyx_k_stream_CDLLADDERBOTTOM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLLADDERBOTTOM */ - {__pyx_k_stream_CDLLONGLEGGEDDOJI, sizeof(__pyx_k_stream_CDLLONGLEGGEDDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLLONGLEGGEDDOJI */ - {__pyx_k_stream_CDLLONGLINE, sizeof(__pyx_k_stream_CDLLONGLINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLLONGLINE */ - {__pyx_k_stream_CDLMARUBOZU, sizeof(__pyx_k_stream_CDLMARUBOZU), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLMARUBOZU */ - {__pyx_k_stream_CDLMATCHINGLOW, sizeof(__pyx_k_stream_CDLMATCHINGLOW), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLMATCHINGLOW */ - {__pyx_k_stream_CDLMATHOLD, sizeof(__pyx_k_stream_CDLMATHOLD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLMATHOLD */ - {__pyx_k_stream_CDLMORNINGDOJISTAR, sizeof(__pyx_k_stream_CDLMORNINGDOJISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLMORNINGDOJISTAR */ - {__pyx_k_stream_CDLMORNINGSTAR, sizeof(__pyx_k_stream_CDLMORNINGSTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLMORNINGSTAR */ - {__pyx_k_stream_CDLONNECK, sizeof(__pyx_k_stream_CDLONNECK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLONNECK */ - {__pyx_k_stream_CDLPIERCING, sizeof(__pyx_k_stream_CDLPIERCING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLPIERCING */ - {__pyx_k_stream_CDLRICKSHAWMAN, sizeof(__pyx_k_stream_CDLRICKSHAWMAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLRICKSHAWMAN */ - {__pyx_k_stream_CDLRISEFALL3METHODS, sizeof(__pyx_k_stream_CDLRISEFALL3METHODS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLRISEFALL3METHODS */ - {__pyx_k_stream_CDLSEPARATINGLINES, sizeof(__pyx_k_stream_CDLSEPARATINGLINES), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLSEPARATINGLINES */ - {__pyx_k_stream_CDLSHOOTINGSTAR, sizeof(__pyx_k_stream_CDLSHOOTINGSTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLSHOOTINGSTAR */ - {__pyx_k_stream_CDLSHORTLINE, sizeof(__pyx_k_stream_CDLSHORTLINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLSHORTLINE */ - {__pyx_k_stream_CDLSPINNINGTOP, sizeof(__pyx_k_stream_CDLSPINNINGTOP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLSPINNINGTOP */ - {__pyx_k_stream_CDLSTALLEDPATTERN, sizeof(__pyx_k_stream_CDLSTALLEDPATTERN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLSTALLEDPATTERN */ - {__pyx_k_stream_CDLSTICKSANDWICH, sizeof(__pyx_k_stream_CDLSTICKSANDWICH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLSTICKSANDWICH */ - {__pyx_k_stream_CDLTAKURI, sizeof(__pyx_k_stream_CDLTAKURI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLTAKURI */ - {__pyx_k_stream_CDLTASUKIGAP, sizeof(__pyx_k_stream_CDLTASUKIGAP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLTASUKIGAP */ - {__pyx_k_stream_CDLTHRUSTING, sizeof(__pyx_k_stream_CDLTHRUSTING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLTHRUSTING */ - {__pyx_k_stream_CDLTRISTAR, sizeof(__pyx_k_stream_CDLTRISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLTRISTAR */ - {__pyx_k_stream_CDLUNIQUE3RIVER, sizeof(__pyx_k_stream_CDLUNIQUE3RIVER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLUNIQUE3RIVER */ - {__pyx_k_stream_CDLUPSIDEGAP2CROWS, sizeof(__pyx_k_stream_CDLUPSIDEGAP2CROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLUPSIDEGAP2CROWS */ - {__pyx_k_stream_CDLXSIDEGAP3METHODS, sizeof(__pyx_k_stream_CDLXSIDEGAP3METHODS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLXSIDEGAP3METHODS */ - {__pyx_k_stream_CEIL, sizeof(__pyx_k_stream_CEIL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CEIL */ - {__pyx_k_stream_CMO, sizeof(__pyx_k_stream_CMO), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CMO */ - {__pyx_k_stream_CORREL, sizeof(__pyx_k_stream_CORREL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CORREL */ - {__pyx_k_stream_COS, sizeof(__pyx_k_stream_COS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_COS */ - {__pyx_k_stream_COSH, sizeof(__pyx_k_stream_COSH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_COSH */ - {__pyx_k_stream_DEMA, sizeof(__pyx_k_stream_DEMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_DEMA */ - {__pyx_k_stream_DIV, sizeof(__pyx_k_stream_DIV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_DIV */ - {__pyx_k_stream_DX, sizeof(__pyx_k_stream_DX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_DX */ - {__pyx_k_stream_EMA, sizeof(__pyx_k_stream_EMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_EMA */ - {__pyx_k_stream_EXP, sizeof(__pyx_k_stream_EXP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_EXP */ - {__pyx_k_stream_FLOOR, sizeof(__pyx_k_stream_FLOOR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_FLOOR */ - {__pyx_k_stream_HT_DCPERIOD, sizeof(__pyx_k_stream_HT_DCPERIOD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_HT_DCPERIOD */ - {__pyx_k_stream_HT_DCPHASE, sizeof(__pyx_k_stream_HT_DCPHASE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_HT_DCPHASE */ - {__pyx_k_stream_HT_PHASOR, sizeof(__pyx_k_stream_HT_PHASOR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_HT_PHASOR */ - {__pyx_k_stream_HT_SINE, sizeof(__pyx_k_stream_HT_SINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_HT_SINE */ - {__pyx_k_stream_HT_TRENDLINE, sizeof(__pyx_k_stream_HT_TRENDLINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_HT_TRENDLINE */ - {__pyx_k_stream_HT_TRENDMODE, sizeof(__pyx_k_stream_HT_TRENDMODE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_HT_TRENDMODE */ - {__pyx_k_stream_IMI, sizeof(__pyx_k_stream_IMI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_IMI */ - {__pyx_k_stream_KAMA, sizeof(__pyx_k_stream_KAMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_KAMA */ - {__pyx_k_stream_LINEARREG, sizeof(__pyx_k_stream_LINEARREG), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_LINEARREG */ - {__pyx_k_stream_LINEARREG_ANGLE, sizeof(__pyx_k_stream_LINEARREG_ANGLE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_LINEARREG_ANGLE */ - {__pyx_k_stream_LINEARREG_INTERCEPT, sizeof(__pyx_k_stream_LINEARREG_INTERCEPT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_LINEARREG_INTERCEPT */ - {__pyx_k_stream_LINEARREG_SLOPE, sizeof(__pyx_k_stream_LINEARREG_SLOPE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_LINEARREG_SLOPE */ - {__pyx_k_stream_LN, sizeof(__pyx_k_stream_LN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_LN */ - {__pyx_k_stream_LOG10, sizeof(__pyx_k_stream_LOG10), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_LOG10 */ - {__pyx_k_stream_MA, sizeof(__pyx_k_stream_MA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MA */ - {__pyx_k_stream_MACD, sizeof(__pyx_k_stream_MACD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MACD */ - {__pyx_k_stream_MACDEXT, sizeof(__pyx_k_stream_MACDEXT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MACDEXT */ - {__pyx_k_stream_MACDFIX, sizeof(__pyx_k_stream_MACDFIX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MACDFIX */ - {__pyx_k_stream_MAMA, sizeof(__pyx_k_stream_MAMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MAMA */ - {__pyx_k_stream_MAVP, sizeof(__pyx_k_stream_MAVP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MAVP */ - {__pyx_k_stream_MAX, sizeof(__pyx_k_stream_MAX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MAX */ - {__pyx_k_stream_MAXINDEX, sizeof(__pyx_k_stream_MAXINDEX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MAXINDEX */ - {__pyx_k_stream_MEDPRICE, sizeof(__pyx_k_stream_MEDPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MEDPRICE */ - {__pyx_k_stream_MFI, sizeof(__pyx_k_stream_MFI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MFI */ - {__pyx_k_stream_MIDPOINT, sizeof(__pyx_k_stream_MIDPOINT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MIDPOINT */ - {__pyx_k_stream_MIDPRICE, sizeof(__pyx_k_stream_MIDPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MIDPRICE */ - {__pyx_k_stream_MIN, sizeof(__pyx_k_stream_MIN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MIN */ - {__pyx_k_stream_MININDEX, sizeof(__pyx_k_stream_MININDEX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MININDEX */ - {__pyx_k_stream_MINMAX, sizeof(__pyx_k_stream_MINMAX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MINMAX */ - {__pyx_k_stream_MINMAXINDEX, sizeof(__pyx_k_stream_MINMAXINDEX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MINMAXINDEX */ - {__pyx_k_stream_MINUS_DI, sizeof(__pyx_k_stream_MINUS_DI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MINUS_DI */ - {__pyx_k_stream_MINUS_DM, sizeof(__pyx_k_stream_MINUS_DM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MINUS_DM */ - {__pyx_k_stream_MOM, sizeof(__pyx_k_stream_MOM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MOM */ - {__pyx_k_stream_MULT, sizeof(__pyx_k_stream_MULT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MULT */ - {__pyx_k_stream_NATR, sizeof(__pyx_k_stream_NATR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_NATR */ - {__pyx_k_stream_OBV, sizeof(__pyx_k_stream_OBV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_OBV */ - {__pyx_k_stream_PLUS_DI, sizeof(__pyx_k_stream_PLUS_DI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_PLUS_DI */ - {__pyx_k_stream_PLUS_DM, sizeof(__pyx_k_stream_PLUS_DM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_PLUS_DM */ - {__pyx_k_stream_PPO, sizeof(__pyx_k_stream_PPO), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_PPO */ - {__pyx_k_stream_ROC, sizeof(__pyx_k_stream_ROC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ROC */ - {__pyx_k_stream_ROCP, sizeof(__pyx_k_stream_ROCP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ROCP */ - {__pyx_k_stream_ROCR, sizeof(__pyx_k_stream_ROCR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ROCR */ - {__pyx_k_stream_ROCR100, sizeof(__pyx_k_stream_ROCR100), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ROCR100 */ - {__pyx_k_stream_RSI, sizeof(__pyx_k_stream_RSI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_RSI */ - {__pyx_k_stream_SAR, sizeof(__pyx_k_stream_SAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_SAR */ - {__pyx_k_stream_SAREXT, sizeof(__pyx_k_stream_SAREXT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_SAREXT */ - {__pyx_k_stream_SIN, sizeof(__pyx_k_stream_SIN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_SIN */ - {__pyx_k_stream_SINH, sizeof(__pyx_k_stream_SINH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_SINH */ - {__pyx_k_stream_SMA, sizeof(__pyx_k_stream_SMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_SMA */ - {__pyx_k_stream_SQRT, sizeof(__pyx_k_stream_SQRT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_SQRT */ - {__pyx_k_stream_STDDEV, sizeof(__pyx_k_stream_STDDEV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_STDDEV */ - {__pyx_k_stream_STOCH, sizeof(__pyx_k_stream_STOCH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_STOCH */ - {__pyx_k_stream_STOCHF, sizeof(__pyx_k_stream_STOCHF), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_STOCHF */ - {__pyx_k_stream_STOCHRSI, sizeof(__pyx_k_stream_STOCHRSI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_STOCHRSI */ - {__pyx_k_stream_SUB, sizeof(__pyx_k_stream_SUB), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_SUB */ - {__pyx_k_stream_SUM, sizeof(__pyx_k_stream_SUM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_SUM */ - {__pyx_k_stream_T3, sizeof(__pyx_k_stream_T3), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_T3 */ - {__pyx_k_stream_TAN, sizeof(__pyx_k_stream_TAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_TAN */ - {__pyx_k_stream_TANH, sizeof(__pyx_k_stream_TANH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_TANH */ - {__pyx_k_stream_TEMA, sizeof(__pyx_k_stream_TEMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_TEMA */ - {__pyx_k_stream_TRANGE, sizeof(__pyx_k_stream_TRANGE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_TRANGE */ - {__pyx_k_stream_TRIMA, sizeof(__pyx_k_stream_TRIMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_TRIMA */ - {__pyx_k_stream_TRIX, sizeof(__pyx_k_stream_TRIX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_TRIX */ - {__pyx_k_stream_TSF, sizeof(__pyx_k_stream_TSF), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_TSF */ - {__pyx_k_stream_TYPPRICE, sizeof(__pyx_k_stream_TYPPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_TYPPRICE */ - {__pyx_k_stream_ULTOSC, sizeof(__pyx_k_stream_ULTOSC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ULTOSC */ - {__pyx_k_stream_VAR, sizeof(__pyx_k_stream_VAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_VAR */ - {__pyx_k_stream_WCLPRICE, sizeof(__pyx_k_stream_WCLPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_WCLPRICE */ - {__pyx_k_stream_WILLR, sizeof(__pyx_k_stream_WILLR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_WILLR */ - {__pyx_k_stream_WMA, sizeof(__pyx_k_stream_WMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_WMA */ - {__pyx_k_stream__s, sizeof(__pyx_k_stream__s), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_stream__s */ - {__pyx_k_sys, sizeof(__pyx_k_sys), 0, 1, 1}, /* PyObject cname: __pyx_n_u_sys */ - {__pyx_k_ta_check_success, sizeof(__pyx_k_ta_check_success), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_check_success */ - {__pyx_k_ta_func_unst_ids, sizeof(__pyx_k_ta_func_unst_ids), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_func_unst_ids */ - {__pyx_k_ta_getFuncInfo, sizeof(__pyx_k_ta_getFuncInfo), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_getFuncInfo */ - {__pyx_k_ta_getFuncTable, sizeof(__pyx_k_ta_getFuncTable), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_getFuncTable */ - {__pyx_k_ta_getGroupTable, sizeof(__pyx_k_ta_getGroupTable), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_getGroupTable */ - {__pyx_k_ta_getInputParameterInfo, sizeof(__pyx_k_ta_getInputParameterInfo), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_getInputParameterInfo */ - {__pyx_k_ta_getOptInputParameterInfo, sizeof(__pyx_k_ta_getOptInputParameterInfo), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_getOptInputParameterInfo */ - {__pyx_k_ta_getOutputParameterInfo, sizeof(__pyx_k_ta_getOutputParameterInfo), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_getOutputParameterInfo */ - {__pyx_k_ta_get_compatibility, sizeof(__pyx_k_ta_get_compatibility), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_get_compatibility */ - {__pyx_k_ta_get_unstable_period, sizeof(__pyx_k_ta_get_unstable_period), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_get_unstable_period */ - {__pyx_k_ta_initialize, sizeof(__pyx_k_ta_initialize), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_initialize */ - {__pyx_k_ta_restore_candle_default_setti, sizeof(__pyx_k_ta_restore_candle_default_setti), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_restore_candle_default_setti */ - {__pyx_k_ta_set_candle_settings, sizeof(__pyx_k_ta_set_candle_settings), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_set_candle_settings */ - {__pyx_k_ta_set_compatibility, sizeof(__pyx_k_ta_set_compatibility), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_set_compatibility */ - {__pyx_k_ta_set_unstable_period, sizeof(__pyx_k_ta_set_unstable_period), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_set_unstable_period */ - {__pyx_k_ta_shutdown, sizeof(__pyx_k_ta_shutdown), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_shutdown */ - {__pyx_k_ta_version, sizeof(__pyx_k_ta_version), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_version */ - {__pyx_k_table, sizeof(__pyx_k_table), 0, 1, 1}, /* PyObject cname: __pyx_n_u_table */ - {__pyx_k_talib__abstract_pxi, sizeof(__pyx_k_talib__abstract_pxi), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_talib__abstract_pxi */ - {__pyx_k_talib__common_pxi, sizeof(__pyx_k_talib__common_pxi), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_talib__common_pxi */ - {__pyx_k_talib__func_pxi, sizeof(__pyx_k_talib__func_pxi), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_talib__func_pxi */ - {__pyx_k_talib__stream_pxi, sizeof(__pyx_k_talib__stream_pxi), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_talib__stream_pxi */ - {__pyx_k_talib__ta_lib, sizeof(__pyx_k_talib__ta_lib), 0, 1, 1}, /* PyObject cname: __pyx_n_u_talib__ta_lib */ - {__pyx_k_test, sizeof(__pyx_k_test), 0, 1, 1}, /* PyObject cname: __pyx_n_u_test */ - {__pyx_k_threading, sizeof(__pyx_k_threading), 0, 1, 1}, /* PyObject cname: __pyx_n_u_threading */ - {__pyx_k_timeStamp, sizeof(__pyx_k_timeStamp), 0, 1, 1}, /* PyObject cname: __pyx_n_u_timeStamp */ - {__pyx_k_timeperiod, sizeof(__pyx_k_timeperiod), 0, 1, 1}, /* PyObject cname: __pyx_n_u_timeperiod */ - {__pyx_k_timeperiod1, sizeof(__pyx_k_timeperiod1), 0, 1, 1}, /* PyObject cname: __pyx_n_u_timeperiod1 */ - {__pyx_k_timeperiod2, sizeof(__pyx_k_timeperiod2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_timeperiod2 */ - {__pyx_k_timeperiod3, sizeof(__pyx_k_timeperiod3), 0, 1, 1}, /* PyObject cname: __pyx_n_u_timeperiod3 */ - {__pyx_k_to_numpy, sizeof(__pyx_k_to_numpy), 0, 1, 1}, /* PyObject cname: __pyx_n_u_to_numpy */ - {__pyx_k_type, sizeof(__pyx_k_type), 0, 1, 1}, /* PyObject cname: __pyx_n_u_type */ - {__pyx_k_type_2, sizeof(__pyx_k_type_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_type_2 */ - {__pyx_k_unicode, sizeof(__pyx_k_unicode), 0, 1, 1}, /* PyObject cname: __pyx_n_u_unicode */ - {__pyx_k_update, sizeof(__pyx_k_update), 0, 1, 1}, /* PyObject cname: __pyx_n_u_update */ - {__pyx_k_update_info, sizeof(__pyx_k_update_info), 0, 1, 1}, /* PyObject cname: __pyx_n_u_update_info */ - {__pyx_k_upper, sizeof(__pyx_k_upper), 0, 1, 1}, /* PyObject cname: __pyx_n_u_upper */ - {__pyx_k_value, sizeof(__pyx_k_value), 0, 1, 1}, /* PyObject cname: __pyx_n_u_value */ - {__pyx_k_value_range, sizeof(__pyx_k_value_range), 0, 1, 1}, /* PyObject cname: __pyx_n_u_value_range */ - {__pyx_k_values, sizeof(__pyx_k_values), 0, 1, 1}, /* PyObject cname: __pyx_n_u_values */ - {__pyx_k_version, sizeof(__pyx_k_version), 0, 1, 1}, /* PyObject cname: __pyx_n_u_version */ - {__pyx_k_vfactor, sizeof(__pyx_k_vfactor), 0, 1, 1}, /* PyObject cname: __pyx_n_u_vfactor */ - {__pyx_k_volume, sizeof(__pyx_k_volume), 0, 1, 1}, /* PyObject cname: __pyx_n_u_volume */ - {__pyx_k_volume_data, sizeof(__pyx_k_volume_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_volume_data */ - {0, 0, 0, 0, 0} -}; -/* InitStrings.proto */ -static int __Pyx_InitStrings(__Pyx_StringTabEntry const *t, PyObject **target, const char* const* encoding_names); - /* #### Code section: cached_builtins ### */ static int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate) { CYTHON_UNUSED_VAR(__pyx_mstate); __pyx_builtin_object = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_object); if (!__pyx_builtin_object) __PYX_ERR(1, 60, __pyx_L1_error) - __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_range); if (!__pyx_builtin_range) __PYX_ERR(1, 61, __pyx_L1_error) __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(1, 82, __pyx_L1_error) - __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(2, 8, __pyx_L1_error) - __pyx_builtin_ModuleNotFoundError = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_ModuleNotFoundError); if (!__pyx_builtin_ModuleNotFoundError) __PYX_ERR(2, 39, __pyx_L1_error) - __pyx_builtin_NameError = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_NameError); if (!__pyx_builtin_NameError) __PYX_ERR(2, 43, __pyx_L1_error) __pyx_builtin_property = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_property); if (!__pyx_builtin_property) __PYX_ERR(2, 130, __pyx_L1_error) - __pyx_builtin_xrange = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_range); if (!__pyx_builtin_xrange) __PYX_ERR(2, 147, __pyx_L1_error) - __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(2, 436, __pyx_L1_error) - __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(2, 440, __pyx_L1_error) __pyx_builtin_min = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_min); if (!__pyx_builtin_min) __PYX_ERR(2, 598, __pyx_L1_error) __pyx_builtin_max = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_max); if (!__pyx_builtin_max) __PYX_ERR(2, 599, __pyx_L1_error) + + /* Cached unbound methods */ + __pyx_mstate->__pyx_umethod_PyDict_Type_items.type = (PyObject*)&PyDict_Type; + __pyx_mstate->__pyx_umethod_PyDict_Type_items.method_name = &__pyx_mstate->__pyx_n_u_items; + __pyx_mstate->__pyx_umethod_PyDict_Type_keys.type = (PyObject*)&PyDict_Type; + __pyx_mstate->__pyx_umethod_PyDict_Type_keys.method_name = &__pyx_mstate->__pyx_n_u_keys; + __pyx_mstate->__pyx_umethod_PyDict_Type_pop.type = (PyObject*)&PyDict_Type; + __pyx_mstate->__pyx_umethod_PyDict_Type_pop.method_name = &__pyx_mstate->__pyx_n_u_pop; + __pyx_mstate->__pyx_umethod_PyDict_Type_values.type = (PyObject*)&PyDict_Type; + __pyx_mstate->__pyx_umethod_PyDict_Type_values.method_name = &__pyx_mstate->__pyx_n_u_values; return 0; __pyx_L1_error:; return -1; @@ -87951,6 +86990,29 @@ static int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate) { __pyx_mstate_global->__pyx_tuple[9] = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_tuple[9])) __PYX_ERR(2, 286, __pyx_L1_error) __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[9]); __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[9]); + #if CYTHON_IMMORTAL_CONSTANTS + { + PyObject **table = __pyx_mstate->__pyx_tuple; + for (Py_ssize_t i=0; i<10; ++i) { + #if PY_VERSION_HEX >= 0x030F0000 + PyUnstable_SetImmortal(table[i]); + #elif CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + if ((PY_SSIZE_T_MAX <= _Py_IMMORTAL_REFCNT_LOCAL)) break; + #if PY_VERSION_HEX < 0x030E0000 + if (_Py_IsOwnedByCurrentThread(table[i]) && Py_REFCNT(table[i]) == 1) + #else + if (PyUnstable_Object_IsUniquelyReferenced(table[i])) + #endif + { + Py_SET_REFCNT(table[i], ((Py_ssize_t)_Py_IMMORTAL_REFCNT_LOCAL + 1)); + } + #else + if ((PY_SSIZE_T_MAX < _Py_IMMORTAL_INITIAL_REFCNT)) break; + Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT); + #endif + } + } + #endif __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -87961,55 +87023,135 @@ static int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate) { static int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate) { CYTHON_UNUSED_VAR(__pyx_mstate); - __pyx_mstate->__pyx_umethod_PyDict_Type_keys.type = (PyObject*)&PyDict_Type; - __pyx_mstate->__pyx_umethod_PyDict_Type_keys.method_name = &__pyx_mstate->__pyx_n_u_keys; - __pyx_mstate->__pyx_umethod_PyDict_Type_pop.type = (PyObject*)&PyDict_Type; - __pyx_mstate->__pyx_umethod_PyDict_Type_pop.method_name = &__pyx_mstate->__pyx_n_u_pop; - if (__Pyx_InitStrings(__pyx_string_tab, __pyx_mstate->__pyx_string_tab, __pyx_string_tab_encodings) < 0) __PYX_ERR(0, 1, __pyx_L1_error); - __pyx_mstate->__pyx_int_0 = PyLong_FromLong(0); if (unlikely(!__pyx_mstate->__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_mstate->__pyx_int_1 = PyLong_FromLong(1); if (unlikely(!__pyx_mstate->__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_mstate->__pyx_int_2 = PyLong_FromLong(2); if (unlikely(!__pyx_mstate->__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_mstate->__pyx_int_3 = PyLong_FromLong(3); if (unlikely(!__pyx_mstate->__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_mstate->__pyx_int_4 = PyLong_FromLong(4); if (unlikely(!__pyx_mstate->__pyx_int_4)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_mstate->__pyx_int_8 = PyLong_FromLong(8); if (unlikely(!__pyx_mstate->__pyx_int_8)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_mstate->__pyx_int_9 = PyLong_FromLong(9); if (unlikely(!__pyx_mstate->__pyx_int_9)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_mstate->__pyx_int_12 = PyLong_FromLong(12); if (unlikely(!__pyx_mstate->__pyx_int_12)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_mstate->__pyx_int_16 = PyLong_FromLong(16); if (unlikely(!__pyx_mstate->__pyx_int_16)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_mstate->__pyx_int_32 = PyLong_FromLong(32); if (unlikely(!__pyx_mstate->__pyx_int_32)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_mstate->__pyx_int_64 = PyLong_FromLong(64); if (unlikely(!__pyx_mstate->__pyx_int_64)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_mstate->__pyx_int_128 = PyLong_FromLong(128); if (unlikely(!__pyx_mstate->__pyx_int_128)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_mstate->__pyx_int_256 = PyLong_FromLong(256); if (unlikely(!__pyx_mstate->__pyx_int_256)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_mstate->__pyx_int_512 = PyLong_FromLong(512); if (unlikely(!__pyx_mstate->__pyx_int_512)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_mstate->__pyx_int_1024 = PyLong_FromLong(1024); if (unlikely(!__pyx_mstate->__pyx_int_1024)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_mstate->__pyx_int_2048 = PyLong_FromLong(2048); if (unlikely(!__pyx_mstate->__pyx_int_2048)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_mstate->__pyx_int_4096 = PyLong_FromLong(4096); if (unlikely(!__pyx_mstate->__pyx_int_4096)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_mstate->__pyx_int_16777216 = PyLong_FromLong(16777216L); if (unlikely(!__pyx_mstate->__pyx_int_16777216)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_mstate->__pyx_int_67108864 = PyLong_FromLong(67108864L); if (unlikely(!__pyx_mstate->__pyx_int_67108864)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_mstate->__pyx_int_134217728 = PyLong_FromLong(134217728L); if (unlikely(!__pyx_mstate->__pyx_int_134217728)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_mstate->__pyx_int_268435456 = PyLong_FromLong(268435456L); if (unlikely(!__pyx_mstate->__pyx_int_268435456)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_mstate->__pyx_int_neg_1 = PyLong_FromLong(-1); if (unlikely(!__pyx_mstate->__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) + { + const struct { const unsigned int length: 11; } index[] = {{2},{1},{31},{26},{28},{57},{11},{11},{33},{26},{38},{31},{36},{55},{7},{34},{34},{40},{54},{50},{60},{28},{31},{47},{28},{4},{32},{37},{179},{50},{54},{57},{22},{22},{18},{23},{21},{26},{8},{11},{14},{21},{132},{1467},{35},{25},{33},{52},{13},{30},{30},{31},{23},{1},{1},{2},{1},{1},{1},{0},{2},{2},{1},{1},{4},{1},{1},{8},{13},{29},{11},{33},{6},{32},{33},{30},{14},{48},{35},{39},{34},{2},{4},{6},{9},{19},{17},{15},{17},{17},{10},{11},{17},{12},{12},{9},{15},{8},{4},{2},{3},{5},{3},{4},{3},{3},{5},{8},{13},{4},{4},{3},{6},{8},{17},{6},{4},{3},{8},{8},{9},{12},{3},{9},{14},{10},{14},{11},{16},{17},{16},{15},{11},{12},{18},{19},{16},{17},{7},{11},{16},{12},{18},{14},{19},{17},{9},{13},{9},{14},{11},{10},{13},{15},{18},{9},{17},{10},{18},{15},{17},{11},{11},{14},{10},{18},{14},{9},{11},{14},{19},{18},{15},{12},{14},{17},{16},{9},{12},{12},{10},{15},{18},{19},{4},{3},{6},{3},{4},{17},{4},{3},{2},{9},{3},{3},{3},{5},{5},{3},{8},{17},{24},{32},{30},{17},{35},{16},{17},{16},{20},{24},{32},{30},{35},{16},{20},{15},{18},{23},{25},{24},{23},{13},{17},{21},{21},{16},{12},{26},{25},{24},{23},{11},{10},{9},{7},{12},{12},{7},{9},{3},{20},{29},{4},{9},{15},{19},{15},{2},{5},{4},{2},{4},{7},{7},{4},{4},{3},{8},{7},{19},{16},{8},{3},{8},{8},{3},{8},{6},{11},{8},{8},{3},{4},{4},{4},{4},{3},{11},{18},{15},{7},{7},{18},{15},{3},{20},{3},{4},{4},{7},{3},{9},{8},{3},{6},{3},{4},{3},{4},{6},{5},{6},{8},{3},{3},{6},{10},{11},{14},{15},{7},{2},{3},{4},{11},{7},{5},{6},{8},{6},{7},{6},{8},{11},{7},{7},{6},{9},{11},{9},{7},{6},{6},{12},{17},{13},{17},{14},{19},{20},{19},{18},{14},{15},{21},{22},{19},{20},{10},{14},{19},{15},{21},{17},{22},{20},{12},{16},{12},{17},{14},{13},{16},{18},{21},{12},{20},{13},{21},{18},{20},{14},{14},{17},{13},{21},{17},{12},{14},{17},{22},{21},{18},{15},{17},{20},{19},{12},{15},{15},{13},{18},{21},{22},{7},{6},{9},{6},{7},{7},{6},{5},{6},{6},{8},{21},{13},{17},{16},{16},{14},{24},{14},{27},{25},{18},{17},{14},{13},{12},{10},{15},{15},{6},{14},{13},{7},{12},{18},{22},{18},{5},{8},{5},{7},{10},{10},{7},{7},{6},{11},{11},{6},{11},{11},{6},{11},{9},{14},{11},{11},{6},{7},{7},{6},{15},{10},{10},{6},{19},{18},{6},{7},{7},{10},{6},{31},{6},{9},{6},{7},{6},{7},{9},{8},{9},{11},{6},{6},{20},{19},{26},{23},{20},{11},{5},{6},{7},{7},{9},{8},{7},{6},{11},{9},{6},{11},{8},{6},{4},{6},{5},{4},{3},{8},{6},{3},{8},{5},{3},{12},{20},{21},{16},{19},{20},{17},{7},{12},{6},{3},{4},{5},{6},{18},{9},{1},{6},{9},{8},{15},{23},{17},{18},{5},{5},{10},{11},{12},{7},{4},{1},{6},{13},{8},{12},{7},{4},{13},{5},{6},{9},{6},{12},{12},{12},{9},{10},{10},{4},{5},{17},{8},{9},{9},{9},{11},{14},{13},{9},{22},{11},{16},{15},{21},{14},{11},{5},{6},{4},{4},{9},{6},{1},{2},{3},{12},{2},{5},{4},{8},{12},{10},{11},{24},{26},{7},{13},{8},{5},{3},{4},{6},{6},{5},{7},{3},{8},{7},{3},{8},{5},{8},{4},{6},{3},{7},{7},{9},{13},{3},{7},{9},{7},{12},{10},{15},{3},{1},{4},{8},{3},{5},{7},{7},{24},{10},{14},{11},{5},{6},{15},{4},{12},{9},{5},{9},{16},{10},{11},{3},{12},{10},{9},{7},{8},{8},{10},{10},{15},{11},{7},{11},{13},{7},{6},{9},{14},{6},{9},{14},{12},{6},{12},{11},{12},{7},{13},{13},{7},{16},{17},{16},{7},{8},{8},{6},{5},{10},{10},{6},{11},{6},{7},{12},{6},{3},{11},{5},{6},{6},{12},{24},{6},{8},{12},{9},{4},{5},{10},{5},{10},{9},{7},{8},{7},{3},{7},{8},{3},{1},{6},{4},{6},{17},{16},{15},{12},{14},{10},{11},{12},{12},{10},{12},{12},{12},{12},{9},{10},{10},{10},{7},{9},{15},{11},{9},{10},{12},{10},{11},{10},{12},{15},{11},{11},{10},{13},{15},{13},{11},{10},{10},{16},{21},{17},{21},{18},{23},{24},{23},{22},{18},{19},{25},{26},{23},{24},{14},{18},{23},{19},{25},{21},{26},{24},{16},{20},{16},{21},{18},{17},{20},{22},{25},{16},{24},{17},{25},{22},{24},{18},{18},{21},{17},{25},{21},{16},{18},{21},{26},{25},{22},{19},{21},{24},{23},{16},{19},{19},{17},{22},{25},{26},{11},{10},{13},{10},{11},{11},{10},{9},{10},{10},{12},{18},{17},{16},{14},{19},{19},{10},{11},{16},{22},{26},{22},{9},{12},{9},{11},{14},{14},{11},{11},{10},{15},{15},{10},{15},{15},{10},{15},{13},{18},{15},{15},{10},{11},{11},{10},{14},{14},{10},{10},{11},{11},{14},{10},{10},{13},{10},{11},{10},{11},{13},{12},{13},{15},{10},{10},{9},{10},{11},{11},{13},{12},{11},{10},{15},{13},{10},{15},{12},{10},{3},{17},{17},{15},{16},{17},{25},{28},{26},{21},{23},{14},{35},{23},{21},{23},{12},{14},{5},{13},{8},{9},{9},{10},{11},{11},{11},{8},{5},{4},{11},{6},{11},{5},{5},{11},{6},{7},{7},{6},{11},{101},{101},{170},{168},{148},{101},{106},{15},{121},{173},{173},{22},{115},{135},{174},{166},{115},{167},{261},{79},{497},{261},{241},{363},{70},{55},{64},{285},{143},{56},{48},{51},{324},{104},{69},{18},{214},{209},{258},{174},{44},{7},{13},{13},{17},{17},{21},{13},{13},{15},{344},{209},{209},{117},{117},{117},{124},{209},{237},{328},{175},{209},{201},{328},{138},{328},{143},{183},{118},{222},{133},{155},{202},{240},{134},{134},{134},{202},{157},{134},{207},{193},{193},{116},{115},{207},{36},{138},{96},{78},{121},{80},{19},{27},{34},{341},{187},{286},{304},{217},{254},{255},{18},{160},{223},{164},{193},{115},{22},{116},{195},{181},{151},{151},{97},{117},{126},{101},{97},{100},{94},{108},{95},{101},{116},{96},{93},{100},{93},{96},{184},{184},{184},{182},{184},{188},{182},{177},{183},{193},{183},{193},{183},{193},{193},{359},{259},{255},{255},{243},{247},{255},{297},{190},{167},{168},{200},{138},{163},{151},{151},{271},{153},{152},{138},{163},{138},{163},{212},{163},{195},{137},{163},{266},{298},{307},{312},{316},{297},{308},{318},{298},{302},{308},{306},{306},{312},{312},{308},{164},{246},{165},{197},{218},{165},{209},{165},{28},{347},{174},{287},{370},{336},{310},{253},{330}}; + #if (CYTHON_COMPRESS_STRINGS) == 2 /* compression: bz2 (12620 bytes) */ +const char* const cstring = "BZh91AY&SYU\276\021B\000\035>\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\300@@@@@@@@@@@@\000@\000`9\375\335\275[\262\300\000\361\3620\203\320\373\267\231\312>\300\037@\372\350\371\322Mw\331\301\361u\367}\357\275`\373m\357{\217Z\214\237npd\264\025=\331w\331\335k^C\247`\000 \006\364k\275nkn\344\333\266\316\3578\036\274\257u\322\016\303\271\222\306\263\0052\354;\233oD\236y\236\315\316\000\350\013\317\214\250\017 \000\000\000\200\005\354\313\267O\027\336\334\356\310@\366z\022\370\360\222D\t\0022`&La\023\310\311\222\236\311\241\232&\004\ne=54cjj\031\352\233SC\310\t\351\250\000\000=A$@\010\010\232#CI\246\t\221\223S\324\311\246\223\364\336\252\247\344j\203\324\362OH\007\251\241\232\215\r\251\247\243A\017I\203)\265=O(\365\003L!HI\245\001\240d\000\365\r\000h4\365\006\200\375P\000\006\2314\000\000\000\000\006\200\001&\224B\010\322d52m&!\252zz4OJ~D&\215\030\206\200i\352\000\0324\000\000\000h\000\320\032\010\222\021\021E=&\215\017P\332\237\252oJ~T\310h6\023OM$\332\215<\247\351\261\246 \251=LO\324\233\304\311\252oJoQ\352<&\221=Ob\024\365\004JD \030\322b6\246#M\r\002\030\210\312i\351\244\002cS\3214\032\030\200\r\000\006F\215\0324\311\220\037j\001\t\003n>\341\346C\322\371\375\0269\307\305\220&\004qOF\264\303\235\033\317\005\017\002*$\014\342\262P&\275\227 \225\325\201@\265\214\020Z\240\230\007\225iX\310k4h\016\035B\301\333\314\035\206O\216\225\006R\214\205\361|\000u\000N\266\000\262\004P\202$\225\tP\220\254\210TPdD\220\002@\025)\210\253 (\311 }{a%\266\000D@%@\n2H,\"\210H*\026\202\203w\270xI\335\375I\372\376\"xq\216\377\2133/\330|%[\267\371HENX?\260\236Fe\032\345\230f\212\243\376[\310jU\210\204\236\026\311\257K0x+\247A9\346r\014Y\272c\213\200\232\347d\362\342\305\214\361\377\301\242\177\260\020O\030\276E\273\345>Q>d\313\"\331|\2721\014-\340\350%BU$\252\227L\340\010^\010\332\222\3261\033\250\305\022(h%\006@\241\206\000F;F\3522O\001^G\300\003A\024\000\250B@\\\323\207WQ\375|\246\277l\027U\n\327\375h_\242R\353\345\017\366\253\014\035\255?p\273\013\367@\353""\323\014~\004]\200}\273\334\177\334\214\024t\277G\177\365\177\301p(\353\265\356\377\305qS\034\303\014\306\274?\344.\203\023h\014\230\215\273_\276.F,A\306\016\327\341]\031S-ZH\307\374\316\0212\202\323\370\016\006\2715r\221\333\377\240O\211\226\246x\033b\212\277\211\024Q\343\2453ZP?\204\\f4\312\344FM\006u\374@q\327\030[\022?\030\261yb\332\022&\277\215p\305\255\215\266\225\016\257\344U&P\311\341\023\371Qp\233\\\341\035\232,\307\363\n\005\311\357BN4\233\376\241h\366\3726\3434\177\330\3123~\327*\033\275?\356\266\217A\306(\374\212Z\306G\036\004\345\017\347Z\312\034\016\014I\206\033\377\n\006\252\033\033H\376\204>lD\3507bGW\364\2129\2634\2728\r \346,\343\036\275\353\312\207\365\"$\016<\010\3641\375p\216\343A\036\354!\035O\354\321\361\311g\355\246n\320\032\023?,\031\231\230\343\343\374\333\225\304\003W\327\247\325\304\253\354\334\025\333o\374\2351\355\377o.\2661X\257\316\271i\325\274W\376\216EM\2403\037\241p\351\322x\221\377\265\311\215\371k\266\032_Y\034\270\233\351\010\373\003\215\271@\177\322\263\266\360\375Z\307\247F\213\343\353\227%\264w\310\237>\323&\256\343V\365\232\366\254\330c\251\217j'\\\371\231ts\266|9\217\316m\244\367}\233\246-\314)\317\r\036\\\370q\332\237)\233V\273\350sS\347\256\324\231\245\013lc/$\214B\304\001\211\006 \306\227:\356\327\255\311\213\023\367_\006\177\026\035\313\322g\223$}\014\020\345\337\255\267&\255\371\367,]\2717s*\355\3749\032x44.eW\271\335\273_[\\\222\2448v\244\301V\336,\032\327\36271\030\261n\350ga\213WwN\226\244\374\255\\:\250KM$T\022\337H4\304\215 \025\365MJ\032\3245\010n\253\324\017b\365#\322!\235C\235\023\270\003\316\217\235N\364{\0244\210l\007\244^\224-\007\240\003X)\342\t\310\t\250SR6\204bK\020\214I+\311-\321^H\304\"\252\nb1\010\250\"\240\212\200p\"\262\\\300\253\244\254\010\341\026\000\276\030\225\224\261 \345X\205lX\205*\013v\255Z\253\300\376N>>8\267\3531K/\030\027\021\321\325\270q\347>\024i\3729\225j\363-\304\357\363\351n\234\264\216\235#[8\307\246\014y\345*j\334\362\276\263~x\315\266\347\256w\356<1\2773\204r\037\333\303w\366\306X""\317\262\020\371\271\313yi\337#Z\277\267lE\371\315\365\366\215\341\323=\251\355\r\337\206\274}\253\201W\366\234Tw\204\274\201\316{S\304\034u\346o^f\2239\232O\231\241^k\"]\\\317\023\032G\336Zs\322\334\363-\277\315=\376n\027\347\235\227k\177\"\324\313D\275\353y#K`\311\224\227\"(\355\350\343A\215!\030\314sli\327\243\307\307.m\235}\375H\356\361\303:\225\253/{\350\355n\301J\225-\312Svv\373\3245\267e\005\232#I\005\261J\212\250\342\024\340\234\023CeJ-\204\274\001i.AJ\211Q*,\251T\241D\224\266\245\026\372*\251Q(\033\351o\243|\n\200TU\025@\250\251\206\360\267QH\245d-\234\213\202\325\242R\274\245\205`,\026x\345\270]\344\257\330\221\355\017jf\022Bc\021\004!\025E\221EI\000\005$\010@fa\200@\230\366\305nX\333\222\345\276^^[\261r\362\344K-\231r+\327\267o\213\203\203\213\227C\203\223\207\035mN\036\016\016\010\3707\260\2400#\002:\221\324\216\240:\2722\3651\354\334\314\335\336)\357k\024J;\305*t\217\001\231N\235*T\374;\224\351\352n\323\247\270S\335\247Nm:si\324\271\017\210B\021\267\355U\203t\254\025\225ec\357\004\234HQ\250\324db\341A\302H\214\220\311\010\324c\324\301q|\301\202\301b\310\242\220P\"\310,\"\254Y\"fG\357U\013*\241\010\250dd\226F\242E\222\006\3134\000\254\023\0052I\000\3423\000\377]\237\315\233\004\327v\236e=\237\r\2506\207\264{\023\372\244\231\250\200FL\231\016/r\333u\004\017\265!\030\244\0220\005\273w6e9\0035\346\360f\034\313\274\201\236\002\310\310)\276\224\241\367x\000P\332\022\242H\031,\273\316\027\nv!\213\241\212\201ed (2\004\001\266\306\333\023\2311\241\215V\020\205$\220\2442c{\255k$!L&\375\244?H\311-D\030\243\021Z\004\221\326kq&zz\000\212\010\204\334\026\227\243|55\375\353,\335\030+\022\311$\035\334t\324(\2230\200\326\370\340\327H\271{!\020\272\034D\006\022(\200V\004\006\322F0\010\244\347:BlC\201\016\023\204;p:\215\267\357\"\212I\301\t\270\336,6h\250\243\257\t\200\340\033\304\025H\244\014a\210C\201\210\272\315\035\\V\321EA\032\241\200ba+\225\032\253\262RJ\212\334\324/~\360\336\261F\206\315\220\177\006\302\r\215\242\343\013\002\001XZ\001\2225\321\006\246j\240[D\262""\326-\021\223%\253\00346Y\327X\323q\034\031\030\023D,\232C8\354\231n\204\n\310\335\006\3427F\340\267,\030\001\201!\027\374XO\001\303F6K5\230\200\316'\343\272I-\312\200\255+\002A`,!\0265\021\252F\246\331$\261\200lf\357\253\271\230\013,\257P\222%p\272W\221+\020i\244\026IY,\222\021\222\014\026?\227\026\333\031\r\220\204\262A\221\214\001\271r\245\354\326\020Q!\020\220\222\017\346\304\335\346\200\335dd\006\267\3106XX\272\306\001\026\321\033\026\n\353\006&-\014\346\023\016\200\330l\212\300\351VH[\270S\375\350B\374a 2\237\374\200\207\241\350\003\327\202v\275\033\234\376~|\363\237\3073fE\352\254\354-}\315\026\350ga\260~\277\327\372\351\365=?\352\270\177\0143\370\367=\2421\233<8kL0\353\331#O\303\033\025\211\362<\354\315\005\030\250\023Pr\030\245\013\374\276\311\220`\256\267\247\311\211\344\321\2442\\\n\021\332\377^\035Ve\226\217\006\207\342pv]\327'%\247\340\213\356\213\265\1771A\306\321\366\274!\032\263\333_\317\0326\307X\333\347[4 \366\357\277\337\224]\347\245 \375d\351\321\317)\220\235\355\027\311\255\t`+\205\007>\t\217{\236\351\214|\220\301\233\035\021S\251a\305c\367\325U8A\216*\265\201\351\t# \366\001Y\"b\247\327G\310\254Z_\334\242N\314\301(\270\036\310\215P\2400\205\307W\306[\313\n,\261\010\021\006\010\323oIN\330\300+\235u\262\222@\212\010\242\261Ec\312s5\311 \313\362~@\350\366\232\204G#\231nlY\026IP\250nn-\320\254\222\334[\240\334\307\237\366\034\357\277\301\366\366\331\000\277\234]};\2048\007\003\201\303\373\177\272\204\006\330\005\325_\350\025\334:\260\260\260\006Pr\237\223\263|\344\2043\371d@L80\220p\007\321\372\016\027\t\203\3741\250h\340\330L,D\247W|\307\\\256\235\223\026,\tb\330\035uri\253\204xR\320\306\332Y9{\231\265\330x\324;\315\244Xn\337\301\331\311\362\237T,y\334\341\377\010\354\020E\263\206\276\322[F\301\234\321\3145\032WI\235\017#\210\351\021\342\364\275\305\016\215\323\336\326\035e\313\260\230\200\022\317>\336\330~ p\t""\260\335\377\\!\3700\240\377\367^vi\237\321\333\347\371\325\345\371\334G\024)\223v\264\203H\013:;\"4W\370\300\026\320\3007xl\267}}m\247\333\235\200\361\337Z\255C?p\240\340\321\024\375\035\0304N\202rZ\326X\253\230\334\372Z+Pq\357i)\010\010\364\001\231\242n\037\332tT4\256\0248\311C\366\270*\372\261+.\353\267\031\351 fC\223\312\332\316{\017\036\354\225c\276\037G\325\266\033\3534\332h:]\004#\323\371\337\303\002C\201\303)r2\253o\333h\303L\303E\353a~\223NZ\267\330\0337\376%\257\313\256\315\345\200\010\3562@i\210.\232Q 4R\244=x\260\2768\273\203\224\016\340\316n\233w7\267F@\004\321\004WUP\000\221H\010-.\004{\026+\3068Cx\332\335\214\032\332f)\2465q;\363q\237\t:\317\337\364*\374\236\377s\233\234!\312\033\340\037\224>b\203]\013\220\220\366QE>\024\302}\224\364\247\272\230O\nySD\373n\024*T\362\246\021N)\224\302|x\241\3054\020\342\232&SrnM\311\314\237-8'\004\346ORs&\344S\202pNd\346E4M\351\362\223D\347Nd\312nM\221M\311\332\236\366\371\271\232h`\326$\236\354\370b\025^\356b]\374\3434\t\213\202\332v\347D\351\227\200\315i\2568\340\302\270\233\240\222V_\347\267\241\307w\035\336+\027\035\265\033o\2161#\361\362\364\372TI\267\301\360|\001\356\\\244\276\251\2419a$\221\222$\n\017)Q%\n\034o(\366\3630\322\275L\036\226\246\211q\243\330T\205Q]Ln\267\234U![\002\344CU\020\307pa\345CM\320\271\353\035\234|~Fo\330\370\262\202q\337\t\241CHr\260\204\022\201\245\241N[\035\001\033=o\252h@\346}\361\272\324\334x\200\320\301(i9\257\326p\346\331\364\336av\207\231\272\302\317KG\243\314\236l>\357\221\024^D\231`,^Ss\325\323\261\031\312w\246\351\32544E\032\326\260\212\214c\031\251\254&J\353\202\200}\nH\223@=J\002tMF\r\272\251\276j1\\\2232fMHe\025V\223\351Rf\302\262\204\323\022\034f\262\275\255\352\361dx*{\375t\240\323\323\305>\365Ce\216\354\337\247\005\362\303x\354;;\036\303\2556>\343\241C\245vBD(\033\n4)\263\333\314\211\326x\227\333\347\274m\200n!\272D(\356\224\224\335\352\034ZOShfc\273PI'8\374-cX\341\350\250K\256j\006!D\260\343C\320qi\304\2160\311\004\240\344JS&q\340`\342`9\2324t4\264\270\3265G\034{\340\334X\202\016g\234>\224\304\251\036\374\244\223t\360YIr\233\223\336f.\224\363\304\306-\262gYH\306$I\306P\262M\262s\316>\014\024\232NN\206\321\336kh\301\270\300\031\273\270\025<\001\030\301\357\030\355\273\367\217n\203\302|\323\323<\337v\367\007\0079\331:\307V\315+\312\204^d\244(s\030\261\332h\205I\316^\277Np\366z\225^\332\257\261\270\327W\030\356i6f1\246\246\357\025W\302\326f\303\306\325)\026\274-/\014\327\240^\232\370\204\305d8U\315\230\252\315\314\230d\331\251\2536\242\244\351\333\332\333\0219\266:I\241\355m\262\335u7L\371 kW^\311\346\016\316\374'\200\236\343\024hv\030Jv^\036~W\267\321\327\222\345\322\3139\0215\220{\204B4\223\254\232\022\212H\306\023 X\306\304`L\3061\206\025YuUU]&\2631\356\3206Uf\226n'\261\231\r\371\264\256\232\344\306\322\206\370\300=}\261\335/\335t7q\345K\016\330\304H}\276\243\362t\0109$\014\227@\354\017\310\357\355\3611\353@\347\235\235\022\025\241\321\361\222\325\324\322n\236\030A5\017$C{7Vf\257\036\256\372\262\232\356\373\253$\024\nU\337AEa{\366\202wf\214\363\314Y\247\322\312D#\2436\226\031\331\340\260\256\234-v\262\302\250\250\275\362\212\270[\036$\304\n(\342\004\342Adw\354\321\013pw\032]\225\264]\272\351\026\321\274~\177\273i \234\n\224\002Pu\214\327\315\3246\215\036g\224\257\310\247\036\206\242\2574\251\332s""\275.\240\251y\033\263\031(\035\3500\315\357\302\215\232\367/Q\230\246\031\247\030\221\216VWU3\037L\347\262\360\236Ff\252\025\264;\247\020a}\207f\354\320\323M4\261\324\204u\211\035l\351\231&n7\010fb\006\177dHHz=\372\252\004\007\326\264\022\267\345I\352\207\250\326I&s\334\361yt\336\0047\2331H\242\224 \216Q@\007TM\r\034\341|\315\340Z\321\010P\0040\3568\\%kv\262\250\326\\\256\370\006\025,\"\321,K;\270\271i\225\324\346\341\363\021\rE\244\243\264\353j\333*\n\330@\213\336\324\255c[\272s\346\000\350v\233\242d\351\324})\323\321H\240\242\346\271\027c\367\360\341QFK6\005B\"\233\3461\205\237;\341\334\256r>C\253\237\031\210\203\277\033\362v\263\244g\372\231RYY\346\342'7\017\362\236'\362\363\367\365\327[\344\230`l\020\326&~\342A\341G\272/9\254\rn=H\363\200k\205\023ZMxu\331\354t\344>\010]\273w\345\027{i\031;\311\007b\352\352VNv\326Jr\023\037\014|K\272\231B\031'z\331QE\310\362\232ai1g\262\233M&\263\204\301\214\233\246g1\355\250\373\221*\216\210\354\303k6\330\317w\206\035\345E\245\214/*\326\007\231\217C\030\026\236D\3207^wP\005T\300\240\316\217$\023\337\014\004 qF\212'\205\257u\275\233^V\213\216f\236\233j\035\315W?\270\347C\231\302\315\300S)\357M2\217&\342E\024&TG:\216\376\256\211\207?ml\033k\212\355(y\252y\240\354\321@\246\253\357C\254o>\237{\226]\330\271\0174\213\327>\327\232\004Vo\345\3705\1776\361\256c|\016^\016\332\336%\341\nR\230\363\332\330\361b\205\255\214\021\256\221\313\020\244\312\031\361w\246\334:\036\334\216\212\375/\343>c\346b0\350\343\263.\025J\323|\270O\272\335\027\204\266\371\035\367je:\304\213G\266K\032qu\254\347\323\277r\271\360\332\261\357\355\247W\007\177V\365\365moG?\247\364\376\227\006\275\373\371\246l\025f\313\303T\227\\\316*\303Msyr7\023\237F\330\363mI$c\026i*+\204\327bs#\275\232\332\230\232\014\323,(,\2152faI6\215$\321fCY\246\2367\222\304q'\224\226k\324\"\310\335\235@\277\0010\346\315\014E\225'>\201\342\3765[=\317v>\311\323\321\323\323yjt\037\023\273\350\020\003\310<\201\362\017\201\021=*|\013\3607=\306O\301\355hcG\337\026>\267\020\326\374\206v\363S\251""\363c\347\234\365\027\036p\3329\033\264k\251\247\251\336tW$\220\204\233\345\3004\244'(\207~\217m\323H\202iL\332M)\247\253\347f\262\244\344P\316\211\0038cOS\307\3314v\351\240\346\252K\315)Z\236Q\270UU3 {x\350>_\tB\345\353\324\314\346L\310fs\016e6&\302\355\274\354\236w\347\302\321\016E>(\205\014\354\367^|\\\315\271\371\246OK\016f\252K\254\271.\213j\006\217EV\226\333\354\333\313\254*q\003\214\\\222\206Bd\260\304b\0352\251\022\247\261\205u\327!I\"p\200\025\225W\\\205-0\t\245\322\006\227\223<\236\324\276.\025\260\203F\307\232\375\215\034k\032\244\304\237R\"R\013U3f\033\002\302\313\004\324\370\234'\322\267$s\317Q\215\014\210\301\3103=\256\221\310\231`\006#\017\023\275\301\361'o\246\206\3707\305\211|y\375\220\253|\016\010\001[\350\241p\207 \032\203=\206t\316\3473\206\"\334\370\374y\374\032\0049\211\214\003*\004r\204\323\302\017\024\001'\t\303\212\300,mK/\275=F\243:\207\331\033\205a@\300\r\202\304\261%\231\375\301\365\217\211\310\000H\216CH\250\230\314n30\3410\342\007\037\r\037\306\205e\313\205O\262\030\2041\310\010\035\320\036\351\322\007JHq\016>\303\337\247f?\234\217*9\024\244\236\211\306\001\316\020\370,\234\240<\276\247\221UTT|\307\232\\*\343~0\252\252\305UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUx\231#\214P\266\201j\372<\2777\341\323L\354c\024\373\234C|>\217\224\366\276\237\311\215`y\267\027\202\252\252\2568s/\035\007\265(\032\261U5\265UUQU\312\332\252\252\252\212\212\274\255\330\345\343\370\264\370\367\335\266(o2\030\230\312\344\267\024\373\031\366\214h\252\252\212\367N\356\3239^R\325\315\252\252\253\233%U\330\265pKUg\356\370\253)03\014\314\314\3155\257-9\221\371+I\031ro\2239\325u`j\267\335\311\274\321!\365\037y\207\275\314H\342\035\230\256\322\034\271.\313\245\314\236\303\356O\007q&\260\374W\214O\201#\320}\275\356\re\262\335\356\200\210Y\335x\230z\261\202\330)\367\276\233\353\340)\365\377\007M\214\271k\322\325\352\223k<\342\314oC\206\024A\322\264A\331\330\250G\034Z*q\023\377\205\320\351\200\344\306\371p\275\0358V\366\014}\311\0207 \341\337W\233^4\347L1T\\\233up\337\242\256""\302\035\006\271]\262\014\242\306L\342q\306\204\036\361[\317\013\024\031e~\250\310\214j\026\2239\236C\336\240\0277\275\236\275k\240\320t\037/\361\205P+'\241\037%bx\257\336\016\033\367\314\0211\337E\006\215\220\014\303\026L\263\271F\361h\203M.X\234\017c)#4\002\001\205\016\004\300G\355P\007h#\tU\353\351\203\303?E\350Mo\3306uqzBj\004\217\254~\314\317R?\245\365\242\013\200\366\262\304\tg\304-\013!\374\256\302\233\341>\310\032\303W=\264\232\246\345\273\255\335o\315\337!\340\020\307_1y\240\220\010!\313\226\3773\226DH\014\220\342\354n\327\247\2240j _\364?'\254%\326\267+\324\357\030\3704}\317\217\005\371$w6\2179a\233'\034\366\207\010@bDY;\240\360\233\270|\324Fx\232\352n\232\227\253\246\206\355j\001\222\231\246\275\251\215N\334a\363F\272\260?p\014\364\244U\023!d\331\rut\335\273\205\311\027\r\215./\330\337\033\365!\216\340\030\010\0341\037\037\253\275\002\223\352\237R\200 N\022\367Q\002\361\010\353,\221\"\0308\251\316\340(\364X\0361\013|\0232\030\314\345QZ\230 \034\210\222\311:\022i\226S C\243\032\020\202\375T\224\031\266\253\255\226\300-M\013\332\335\263\250\3603\345!\352\220@\341s%@J\342\333\323f\237X\327\n\365\025$o\354?&!\226\013\251\363\013\202fC\205\013\211\212\367d:\306\260\035\360\357\244k-Aw\355\023\213\246e\267\270,\215\260\006\225\216\221\341\342\014\254d\030\035\336\240\272U\304]\211Y*\333^8\345\003\303\261\216\003E#\366\362QK\2748\232lgD\362\002qv\361\017\263\235\n\t\350BT\372/X\252\037f0R\261\251k3\\\0353d!&\010\020v\254\340\320\035:t\350\355\371\236nC\3536\031K\207}u6\211\234H\347\t\361\342\311\216\021-\245N\262\314b\ra`\365\321\005\227\315\360\373\326\344\372F\220\361OOl\027\312O/\265\221\234Vwz\311\233<`=Jn\326\342\254\275\304Ex\361\3653'\\\r\250\376\337\034\2600\024lC\347d\203\nrU\333<\242\271f\022 \366\0142\035\342\215\357D\000\3203\000\310\240P\240\212\t\024\022\252\006\332\n\250UW\tWs\3536\226x\250v\236\375\312\303\262W\035\212\366+\003\261'g\273\222t\366\035\033>\032\303\270\n}\336\347XO\227\201\025s\357\333\344\311\013\271\323\211\223\222<\371\014\020r""\t\253\355\016\246\017P.\322\3503,\322\277N\317\367,\006x\027\333\235\251+\241\352/\236\337j\370\316\316V\302u\225\350\275\373\222`\366\014\201\010\372~\353*Z|CM5\374\345\023L\273\233j3\026p\365\336~\212\235\030{4\2248\272\316\273\343C\354\325\023\350\370W\246\024F;g~\222\316\262\344\226\213\035\030\006\323k\372\345.-0\207/\331\206\226\037\257f\314s \233\344\307=\346N3x\250A\201\221\264\020\355\236\335\327O\227\304\320\016\310\216)I\210\240\275\3726Jv,\276\213\273\034\365J\022\017\264\300\022\016\366\235\035\021\026\311\211\205[\366\027\003~\346n\347E#\337\255\250\020d\314\310\345BDFUy?H\3649S\304\354\303nn3\271\227\276v\342\264j\334\347\025\031\025UD\025\231\251gt\221\004\372IB\204U\001\224Tj\030\367LGi\350>L\034~^D\313\210\263dVl\226x\240HAc'\244\345\314\225X6a \257e\2343{\211*\351&U\302\275\240\3611@\340\360\rKYM\202\007e33\222\247\2652z8G\351\310\306\335\007-\2770-\004\326F\3318MW,\341P\373\356\227\317\265$\023\251\253{\207\211\007\211x\222.!PE\302R\344\323+m:{\206y\205\247\nzL\023\320\304\363\\H5]\241\261d(\226\241ni(\322\252\006k\245\336[R\324\274h\273[\271\265\256\361\251\357\361\364\344\234\247\016r\321\205\245\252+\214A\032Y\347\361\370\347\216\006\331\275\334\206\262=\225\025W]\n\341\306\245\252A\265e\272\370\210za\r\225\004^\264G\270u:\t\204\306\371!G\366S\331_\241zz\320X:X\315f\242@a\2437\250\025\327D\312\275\307p\367w+\360\034\206\257 \246\367v\213\227\n\302\345D3\t\310$NE\344\367l\306'D\353\360V\217\327\353\245\300t\224\250\370\215\005\310^_\261{\2647~v\343Q\241\017.XH\234m\237\322\307\253\300\274\325\367Px\227b\372\221\3176\014\203\307\177{vi_\247\227\t\366\225\312Xh\372\357S\251\004\214\332\365\264=\370L\204a\347\205\030\200\310v\314\332\341\236\010\251B\216\352]\377\211\317_\204q\206\nLp\355\261\006A\001\223|\366\213Z&S:\335\010\220\002\233\000\231\233\331\003^\337gt\272\357\0143\030\322\274\206\032\307\025\327\333\354\276\262:\224\203u\321\036\265!M\210al\221De9\003\322n\036\020\\)\025UR\255T\252\255b\247\02144G\005w\217O\255.U#\rHx\t\017\000\236""\035\341\315\357d\001\306)\217\345\253\327\230\302a0\370\036{\265\324\313\235W+\014\002X\014\260\310\032\243\246\224\261\206\303\237w]1\251\254\333\333\250\333!y\273@5\006T\014\246\244\324\032\216a\2644\347\314\357\205^N\232P\257D\241\341\230KD\201hg:\010\231e\"H\021\204|\375\300{\372O\0342k\210{}\254\250\3450\304\035m\024\366.\363\331\027\271\354{5)Q\325\220\272]\300\304\313\373\232S$d\252\227\3324g\026\240\320P\007 \302\360\t\246\250yXr\330\360\373\376\277\253Bj\306\333rO\014\020\016\014C\213Dn\010\305\027\rH\026\014\244\203s\005\352T\275\010\363\232\200\324\233,\324\370U8JQ\337\271(:D\345Fv\326\002%\3666HZ\355N^+\206K\327\257[\346\246\337gT\016\357d\227]\336\260\311a\233'\023\262\035\311\261\002\000\356%fB3!\212X\233\022\354\360X-n\363\035\344[9IM\017\231AtR\021\257\n8\273\300\214\376m\016\204\351\3331\373u\342\252\2200\t\234\030t\023E\233x\374I)L\344\240\327d{\230=ld$\255\322\201\242V\030L=\353M\236\374\365\375y\330\366\230C\325\203\303\317\t\310\371t\204\225?\025\240tp\262\375\003\242\270\222r,WJ\266\t\225M\001A$\303$A\214\322\024\231\211q\251\001\233X\016\246\314\231}$\001\366\247i\217=\353\215M\343\321\177!\356\247\315\254\311\230H\311\001e\207@\235i\271\351\235)u\333M\320\202\030\302\n4\nHB\262\035\214\3739;k\351\301{spi\302T\035*\370\035=\034\346,\312\035\315\222\240\324\006\261#\255\232\314n\010v\361KbM\025\324\032r\363\3648`\303\345o\200\302\016\001\367Y\301q\376\3620\0379\246\231>\331\356/*\373\001\256\204\313{\341\005\263\033 \233!\0332\022\276\277gX\346\031{\002*\322[\262\335\200\311\230\303\363\245Yq\271\214\372\261\335\220x{b\214\237\311M|]VQv\366\302\004\031\373\212\236Z\230RsN\220f\030\216\351\372\205\253z{\320 \317\261\330\346\221\373\206il\331G\037\037*\314\370[\2521z\355BMg#\305\272\036\220s\223G\251\257v\243\014\334\0252?i\004'\3270\240\273\345\032J\323\265C\333\333\333\346\272o\263$\334+\235i\332\263\264\235\247\241:\233\313^\357o\253\231\347\177;`\356\256\r\335\0363Y\036\024\217q2\325x*\356\241UY\330\361\261\340\351/\331\023\265\365o\230g""\230\264\275\241;\235&\305\016\237\017O\000\244\314\233\215h0{\220\342u&\203\362o\310|\215\320\212n\335\273\253\357\301!\305\320\247o\255\214F0Q`\010\254PP\214Tb+\251\332\014\315R\315\021S\2445S\352#\003\264\227`\r\330\335\226\014\376N5\210\037\027\321\343\362<\035\320\014\200\020\360H\036\225\244\257/\n\013j8\350\252\266r\257\357( \234\375Y\020C\217D\234\236\212\213D\271\010`\030\000\254\2201yfr\014I$3V\216:3\\\213\372:]\201\267@\322\226%\306\352.\354\345\327\210i\235z\300;\301\023\274=\343\300w\025V>\271h\243\021Y\353\243\212E\307\034\230\266\230\226X\010\344\360$\370c\010T\360\035\247\025\320/L\276\01049\367M\260\214\226\235]\333.\033\216\324\004\023\264\243\201x\343\017{\2158\023Q\211(\304\032p\363D\3641\347\211\265\300>K\202\264\231\222a\236L\350DI'\014&\363\312\207T\310\007!?\370;l\230\301i\222@\275\371\205\225\001^\337\274\027X\031m\235\257=3\244\320\304\260=\271\017)<\250u\001\326\364\241\260\367\266\371\245\201L\005\177\220\254\235\363b\007`\004;\013M\257o\257\300C\270\337\343\355m\331j\353\030ox\330\037\305+\021+\n\302\026\214B\207\274B\261'\n\375W\314\216\267\335cF\357F\350.\031\264\332\2128}\004\002\007\336\033=\"\0335\247\241\265\244f\212Bq)\356\274\336YT\236<\033\261\344\252\245\215\037\314/^D\324\006\266\2456!%9\203\335\307\255\247E\332\264v\207l\361\233\260s\272\336\020\005Q\\3\361\317\254\007\266;=\240\370^\023\370\236\027\261\210?{\353s\337\374n\306%v/\207\362z\327\300\354\234u\003\335C\233G\257\234\034\333\335\336\236\373\227.\237\027\246\216V\306\010\327H\345\210Re\014\370;\323m\370\275\253\246n\313,\237\333G\322\221\215\231\255\364=-:\305BE1\206\302\317\025\013\372\313z\232\214}\265t\021\237\n\303\2075U\027\210o\253\300\260\3407\301\323\304\337/\274\234G\346(\031u\337\255\314c\342\245O\014\275\335\354\250\261C\020\330\207\036.w\224\374\317&\222Y\202\263\021\317\216\322\225\025\215\351z\315xQp\2119'""\237\001\237\254\317\371\302\316d\321L-\206it2\237y'S\366\023\370\276\265\017\236\321=)\253!\237\255\2565\326\3055\023,\220\223B\241e\202\315\026\221\023U]\252yx\340\241\206\250\033@Y\001\232\004\212\024\251\263\223\010\270DRnn\356,\037\360x\346\215\n\362x\220\022(\201\361\300_:#J\305\010\n\021B\"\260f_^\220\361\204T EB\021`\n\035\266 \251\322\362\">\341\016y\344\245\202~\341\333e2?\2662\t E\0141`I\030\375\036\336a\333\030|\306\317\027\332\271\311\336R(\211\233U\312H\021G\322c\261\204?\357\027\377\206\037\323\217\250@\014\020\014\301\013\314\242\243 \242IPg\242\035B\203\320\3735\370 \207\303\014\317\372\323\033\000C\323`{G\327\177kk\372\207\304im3Kk\226\027\314R1*X\221\337\254Z\370\360\235_\257M}\217 }\260\221\334\201b\025\224\275\345\313\332\301h\321\031%B\211\335O\324\000\234\265\363\0002\n\310,\200\201\361@\220\017Nx\224*\240~J\017\264\303\241\032\201\360\217\375AU\362\016\316s\235\0062H\206\001\310\332\272\r\330\313\231b/\245\200\210\274\201\311\035\222\257\205\336\313\353\356\001\030P6\001\210\310\223\300\326\264\255zn]W\227\322\027\210\310\323\205vU\360O\273\345\276\257\247\220(G\000\303[\275\370\205\352}\335\233\364\025\3424\224*A=\314'.2\345\236\273\204\252T\202_\2364\347\241\314\014z6m\037\027\303\325\350\274^\274D-\3270\353JpZ.\222\2169\202\343\230pm\027>9n\214\\ \013\211\227!\357JJ[>QJ9\234y[\224\370\276I\245\302R\t[\362rZ-\016\036:\320\343\325o\213\307h\366J\222\202\025l\235\022Z\006|~\241\326\365\324*\337p\237p\366)\347sW\332y$M\250\217i\330\207\340\017\225\264(u\257\337\211;\016\312\023Y\244?t\177\250\344Uq\237<$!\242\345\227\351\345.\020r\331\362yR3\231\t\026\030\014\346H\244o\370\376\200\356\344\334i3\2405L\257&\244\374f\237\321\006\334\376\210r\273<\335\332\377\207_\017\222\335i\336c\255\301\266\244;\257og\2303\230\352>p\2670\240\352\237\205\352\235;;\304\253Q\366:}\377\\}\362\326\337\"Z6\224v\376\357^y\307\344\010\357\222\305\353\322\347\316\311\366B\033\344,OW\333\353\035q\262Q\356Qr\250\252p\267\333\371\231\003\237<\242z\322^\204\274/ {d\036\233;o\244\220Rr\007\216_\261<\247\232\236\3428\242b\316c\333\023\333\031Ye\253&\350~\177\214\244\201#\332\233\210\234\261S\347T\342\203\204\037\235\007\330\000\374\242\374\002\036 '\202'\355\240}\365\017\266\203\373 \007(\017\032\247\032&@~\242/\357\003\343\027\240\017T\003\363\252\033\302\236\252\007\000=\364\177\030>\312\277\320\247\242\2175O\254\017y\0177\245\252\177\224\325:v\340\243\233.V`%\200(d\206\030\231zU\203\226\261\253'\014\274{\006\324\023-^\247\016[\227%\202\025\344jK\266r%m\330\201+\315\026\362\310i R\310\254\265\025\210A\261\210e\274\315\267\230q\340\020Z\027d\220\3173\005d\241\0243\231\2300X\263\210\253\200\273x\251D'\030\220@\014\000So#\256,B\023\202\263\020ev\035\241(\020\206)u\270\304n\033\202\270b+\030,\216\343i\272\315I\214\356\334""\305\250n\r\201\260\322\205(@\201\020\n\034\003\223\270\320\016\264\013\3023\025%y\002'\025\202\330N\322\021\010\233A\013uCsN\325\350\270\032D\313sF\224qXk\354\335\236(\216\0015f\234eY\364F\304\"\246\000\210\000\216\343e5\031<\307I$U\247i\350\202\204I\2102\014\203\n\22482\315\264\270\302j\342\022\203,\204XdiG`\004k\030P\224\310\005\201d$\230\270\345\2634\215\315\323\231\272\334\254\260\2066\300Hid\202\010-\024DDF\354\245\013\206]\265\270\232lk8\316\327\367Q\346\264\352\352\307bLf\367\022w\020\300\347\263~&W\315|9\246\177-)\375\230\306!\314\205\302\323\203\205Mspt\323x\340vk\035\032(t4{\311{\326z\335\374\340\255EU=kW=}y2w\255QO\241\363\376=ws\254\351\344?\021\352\035\350\316\320\221)\0335\017\n\\\266\230\340\342\274\\`Vq\214;\253\035\340\220\302\3144;\312\341\000\212c\205{|\016(\000\216I\031\266r\230\270\201t\000\302\241N\342\334\232\323\247\271\221\032w\036\356\221\247@a\020U\240\342@\344\313\306be\240\260\346D$\273VwmE\n\313\333Z\254V\005\202d)\342\223&\034\361c\272V8\333k\204\035A\343rO\023\033$d\220\003\2304\320\211Aw\343l\227)yQ2\212X\016N\014H\265\t\025\"\025\024\026\203J0\024\220\260@\214\031 \222\226@\241K P\264\201B\226Ie\241)-\222\311K\tB\224\201d\264\241CT\211IT\001I\021\211T\2455H\323\024\020H\thJZIc\001%\241,\020\006Z\022\302\322\005\002\330\005\222\330K\006A\001 \201\350\262X\220f,\222\205\262K\022!K!Ii\013\006\002ZB\244\020HT\205-\002\313am\222\336\001`l[\234Y[\034\342\204\257\037\331\037\321\n\372\272\340\177{Y\346~\304?\265\274~y\244v!5\376\314\254\233z\261\032\022W\353\353\207\251\272\242\324\360\301\332\301\241\344\213\226\013zNGy\201\230fff\337v\356\333\215\256.=\356\033\361g\326\327\257\206\324\217\321\377\305\334\221N\024$\025o\204P\200"; + PyObject *data = __Pyx_DecompressString(cstring, 12620, 2); + if (unlikely(!data)) __PYX_ERR(0, 1, __pyx_L1_error) + const char* const bytes = __Pyx_PyBytes_AsString(data); + #if !CYTHON_ASSUME_SAFE_MACROS + if (likely(bytes)); else { Py_DECREF(data); __PYX_ERR(0, 1, __pyx_L1_error) } + #endif + #elif (CYTHON_COMPRESS_STRINGS) != 0 /* compression: zlib (14139 bytes) */ +const char* const cstring = "x\332\335}\311[\023\311\373\370\220\304\031f\\F\024\227\031g\346\023f\\@\001\005\227QgmH\200HHB\0226\021cC\032\210\204\004\262\240\270\214s\344\230c\2169\346\230c\2169\346\330G\216\376\t\376\t\277\367\255z\273\273*\033Q\321\371>?\037LU\275\335]]\365\326[\357VoU\337w\336T\342\361\344\212\232\211%\023Nw*\225L9{\303JD\361z\375\243\021w0\3307\242F\235\376\345\247\332J\206]\030Q\\\021\377\310\003\367h\230]\t\250)uS\313h)\363b@\t*S}#\331x\374\372\210\246\246\340\216\014\\N8{\261\024K\257;\177w\336\350w\372\264l&\245\306\235\177`\001o\306+\177:o\364\271\324\364\272\026uzc\t\315\225\204'\215lv9\2569\335\317\267\222\t-\221\211\301\223S\311\235Xb\315\251\354h)uMk~e,\233Xa\235\363%3\316\261d6\021eM\035\233\361\215F|\376pd\314?\343s\365\231w\255\253i\247\232pf\023\351\214\212\257\334\322R\261dt<\225\314n\325\3240\036\364\317\004\204*<\211\255l\206\335\003\030uz\0221lL\354\205\306\357\366\370\0023av7\240\026J\236\260G\361z\036\272\371c\351\373\236\004b\tZo\215\201\307\027v\007}\212\027\207\301\037\204\033w\240\276\250sBMD\241a\374\216Y\250\304\025\231P|.\257\333\274\303\033Kg\234\341\335-\371&\257'\024\216\204\027\002\326}\326\340\231\335\027\037`#\311\020\025\366\370}\r\236\232H\306\243Z\252\3013\023~\257\313\035l\376D]\333\304\307\3446n\231\317B9\2539W\0019\223jvu\023\006I\211\252[\231\330\216V3\342\336\330rJM\355\262\241\250\035\006\257g\204\r\2020\000S\356\220\322\254*\037\020\025V\023\312nm%S\031\252\004+\010\315\004\002\376`\330\355\352\303\353Z\"\231][wn\245b+\232SM\255e7\201\026\323\367\235\332\363-\2308\360\030\334\24493\353j\3069\272\233Y\007D\307\322\316\250\026\217-\303k2Z|\327\231\316\300\263\330M\270)\341\014\270\003\003\267\356\336\002J\214:S\032N\276\2643\235]^\211\253\351\264\226v&W\235\313\331X<\023K83\200\312\364\240\323\263\352\334Mf\235\t\r\336\225I\002\326\322\322\003\231u-\341Lk\031\3148\257\250\211D2\303f|\004\036\207\356^qFc)x\t\"\000\236\036S\343im\320\237\315\014$W\007\202jb\rf\0364\304\223\210j\317\031\002\374@\312\376\261HP\361\215\273#n\237\013\320""\351r\317\367IO\2042j*\323\354\231PX\t\206\255\247ZM\034x\256\311\314\241\007W\000_\313\032t}M\305\016\310\320\255d:V\017}\241\245\222\004\201qP\021\014S*\235\211\255lX\340\344\016\022]2\016cI\300\364\212\n\023/\r\364\350\004.\021\303\211\313\257\244\357\233$\216Y\203\341%\223\361\276Pls+^KV\241LJK\254e\326-\346\27080|\343\306\340\340\300\320\215\033K\300\024\211W\366;\027\02128\310\200\343Z&\203\225\230\027o\000\220\030)\334\t\267\321\323\346\215\234\257\3025\270\200/`Us`\3377N\370\027^\207\2162\024l1\262\214\2558\237\245\324-`z@\305\214\323\205\001\327#W\340\216e\240P\025\204@\014\031\325\252\272\242\001\321!\236X=\010\204\221f\264\227\306\036\307Vw\235\33146\"\226\210\306vb\321,\2606V\227s\225xM\332\271\274\0133\006\020\023\305\373TVQ6\021[\215A=\346[\330\204O\363\016]_I&2\251$\264\237\325\213C\022U3j\277q\335\254\232Uer\2164M#\230a\032\033\205\224\226\316\30638k\314:\234Pu\032\330&\233[\252\363\311\223(\314\306'O\240\304\352z\362$\221\335\334\332\005\200\232J\251\273ig/\264\no\333\202\252\325\364\240\013\252\030\303\327\341#)\204'\343jJ\202\367\365;\201\231\260\332X\035\254c\232\272\262\216oLni\211~\347zl\r\006+\236|\326\357\\\211'\323\032k7\247\300A>TD\2778\223\237\3052\353\2546\234\322\000\2100\204Dx\373z\373\234\320\365\365dt\3209\267\036\203wlh\273\200Uv\2617\335\007\031\r\206\007!D\307i\3473`\021\254> r\206`\254\327@(\322\210\201|x\212\217,\336\300_\232\200\036\246q,\201p2\273\203\337X\264\305\030\220sM\313\340{\254\211\215\215\007\374\311\004\341L\260\231\005}Nna\031\332\261\013E\"0\253s\316$SG\030\375q\372\341\034\0160\n\252\3143l\0320\342M\024\001\026\255\001\266YE\006\251P\257\033S\306}\336\203\001\370'\276\371zX\0310j\034\260\004\023T9\220L\304\305\267\341\223\003\274\216\372\261\021\013}\302M\306\343pi-\335\273(\336\326\277\344\\d/d\327\"\320\352d*\262\361\014\013K}\274\261\256\344\n\223:\\\223C\342j\362\200ED \023\330\024\204\311F\343\311j2\225\201\030*A\t\230\203XY*\271\006\325mB\365+l`vb*Q\300j\262_\242\003xY\355\004$\322\210\201\250\262P;@\350""\036\200\001\310\246\022\342\004\2261\210\257IrFk\022\031\343S\310\2708\235\003\371\"\231k\211t\026*5\306\221\321\271\032\177\206D\303\324\t\2520\225M\310\370]\352s\376\302\010?]7\\\006\211@\013\361b|u\220\232Bu\031\330\362\020\262\336c\340\244wJ\243\337\372\245\341d\322\t\372\317n\013}#\234\212\201\024\316\002\023\252\021=pa\253\245&M7\214k\t(\362\331z\240\366=\223\330H$\237\221\375 \025\230\010\237\361M\372\374s>fN\314\242\026\207\003\264\005c\004\225\301\010\302\234\205Y\024\217m\3062\365WA\025g\342\210]\236\323\200Cb\367\344\327/9a\016\014\376\325\357t\366\366\365\"\202\026\377P\243\321\010(9Z/\242\tX4\016F\337\245\336h,\275\025Ww\031\241\366\001\027\277\324\273\206\232}\037\316\303^\023y\026GZUcq\203]i\254?+\311\250\346\354w\256%3$\20183G\263\341Y*\tm\212\306`,\322H\303\342\3658\223\367\234 \243\261\325U-\205\210\024n@=\016\271,4\332\031e\370\226\tT\"I\213\367l\306\322i\316\270\266\263\240\302E\2710\003n\217\002t\r\225\363\035\216R|1\352\022\2505@7 \327\307D\332`d%\231\322\0067a\272\304H.\361>\203$\007A\016J\257x[\026\346\377z\335\035\227\322\275\227@\250\300\277Ki\320\0224\240\366K0\031@\273\275\0361\364\206\301\255\3471\002\255$77\223\t\001\200\350\026\212\274\n\0230\270\202B\207\263\005\016\300F\360\034k\033\317&S`YhQ\224\333\034\300E3\345\2318\346\371\364.e2\353\360\036\324=\224\321\321\021\260\240B\312\250?\244\270\024\027\374\371C\243\212k\036\376\202\240t*\001\277\022\364\373}\354\007\256D\"J0\250,0C%\244\204<>%\254\300\377\2402;\356r\317\302o \350\031u\2032;\312\364\312\020\0279\351\021\366\222\021wX\031\361\007F\222\321]W\362i\014S/\320\r\246\241u@&ff\265\024\003\216\216zF]\336\341\321\240\177.\004\231\233#^et\322,y|!\217\313\2159\257\307\347\016\205\203\236IV\002\215\331\270\200z6\264/\004\240\t,\317Mx\302\356\020\230Y\036w\020\353P\260I~\237\3335\242\214,`\3315\253\370F\335#`\374OBq\304\355\r\243Q\206\331\240[\231T\346\024\274k\324\353\207J\307\247\224\340\314\210\377\341\014B\374\360\224\342\305ZBs\2001\006\232A\373U\t\207\025V\227K\tN\302\2033\256Q""\377\254;\210\000\377\003\017%\330L\314\006\225q\277o\314\273@\227\334\276\361\031\357\030\274\t\363\263n\037\344\204\273\tB\245q%\200\235\306\377\254\223\010\202\001\001\264`\367x}\023\312\324\024{5\330\313\343\254\003>V\000\333\323ce\202\376\020\242f\3023>1\007\025\260\354\344\2442)\344\246\374\210\222\t\377\024T\022\360\214\273\375X\017\274\331\027\366\214*\336\233\306\010y|>7\353;\230\271n\264\025\315\006LzF'y\277(7\262\200\275e\203\004\203\000V\360\210?\034\366Oa\321\357\033\367\272\307\307\335.\352\005\003\300\200CV\030\201)%<:\001\025y\375s\274D\3436\345\017\326\340\215 T\362\033m\014\000I\214\3626\001\365N\206&\2249\216\237\240'\344\036\2031\2759\345\206J]\330\261\220\033\r\366\260\2077\204A&\374\376\260U+\024\203ajd(\000x\200Ka\177\000K\240\363y\335\256\000\320\205;\350c\000|\033\220\341\234g\024\273\037V&g\202\036\226\t\315Lz`\\1?\021\234\t\205y\353\200\316\351-3>\317\364\214\373f\320\303\tj\206Q\000<`N\230y\002\230Mw{\274\243S\376Q\1770\350\006\002\r\301\337\2044G\3211\341rO).\317\254k\336T\336]\311\014\300\334\363\001\3676\2301c^\277?8\246\246\014\301o\244\203\221\010J\363H\244\026\260\332\340\306ume#\002j.\251\032\214I\013\327Aanq\0255i\3515\3746\246\rD\322\032(\263i\256\212\t\267\240\217/.\224Q\304Ju\000\327\225\312`\211\241\254\213X\300\232\356\210\360F\335\021\2567\350\216p\265Y\353\205[X\353k\313(\352\004\030>SS\204>\231=2\233\275\032W\327,\314\254\325\250{\r.\310\250D\270\245\331\232`T\203\315B<\231\334XVW6L\000\327\336j^M@\271z\322\363\3142\250\252f\276NM\224\2564\354E\272I/\322R/&\302\021\327h\300\035\364\370]<;\241\204\334\220\303\324\037\204\014\260{,\207\203n\037r33\017\214\320=\001:\2317\371l\002\254gf\"x\246<\021rw21\031\342r\322\2001\331\030\t\301\313\000\346\002\3162\343\r\207&\225)\005\353\205\007\334\343f&\242 \353\263\212\314!:\352\016\204-P\310\353\017\270\275>\257\177|\350\006:\212\247\240\242Q\027\376w\317\2071\031\363\314#lJ\231\rL)\220\235gN\247)%\202S\235\022>\341b\031m3\022\261@|\226M\001\257\302\026O\215A\277\\\001?\264\001S""\006\362\370\340\217\327\007Y\205~\r\300\014t\317C\351\324\224\177j\n:\212Z\202\017\004\222OSS\376\221Y?\327Y\\\240\263D\"\001\340\201\n\334\013\312\304\030\010\"\267\t\341\270\nxY\205<\231\202\213~/\310v\351v\016\241\333\003~\200\354>\207\377\254z\237\366<\023\324V\203~\340\215\243\001L\360?\250\201\240\0370\207\035\366:\250\251q\246\210@=J\0200\210\272\203\3077\021\232RB\323\301p(\014\222i\026$\352\350\004\373\031c\277PAhf$43\025bs7\264\256F\223\317P{\3419\246\324\360\254\241\326X%\341b:|\023\264(\370\233\300\345\007\322\310X\326\317\022\027\373\341\277\300\271Y:\317\177\203\230\004\374\370\213\032\232\221\322]\320\001LX\345\220\260\233\231\242\3063l(q\355\302x!*h\230\370\003\360\013\032\030\376\032J\030\317\013z\030\001\270*F\005K\033#\000)dT\022u2\002Ij\031\207I\232\031\201\004\345\214C\014\375\214J\206\212\306\2135Z\032\001k\0245\003*\350j\034$\253k\004\003%\302\3121\037./\211z\033\007\231\252\033\025e\355M\002Z\200Z\035\216\240\222\032\307a\\\2212\362\2062g\224Q\215\023\363L\245#\000iuF\211\251sR\001X\032\225\005\365\216Cj4<\0022\005\312\310\213z\036\207\221\202'\025\014m\217\003E\205\217 \222\316'\300\200\262xI\036UA\3713\001\026]\324\250\200\022\320\002\370\205~\030\272 /\t\352\240\001\2205B\016\255Q\n\t(\350\205&\204\253\206T\264\264C\002H\n\242\001\023tD\016\342j\242\221'M\221\212\206\262H\305\240\320mQe$\210\2545r`\255\342\210P\320\0351\231B>\3035H\226\t\361_l\026j\216\230x\220\2650\346\304\001\2409\342\212#\352\215\221\010\255=\342\222Z\304\007|;d\202\340\016\005\021\305\224\2300\256>\262\245Y\0210\226\3224\\z\3242\010\342+\201V\331\003:\010/1\307\266\271&a\301\275\244\230\360\222\177\253\351\215|]\243\356\002:K\244\226Y\020j\232\240J\230%\324&x\201+\024<\037\3424 \252\025B\0215\013\\ d3\231k\016\006z\254\025\"(\240\346\300\326\365H#\020\363\\\177\220 \246\n!A\231\026\201\020\2447\246K@\312\352E\025\202\022\020\207\224\003\235\202\345\350\216\331\000K8\214\213\177\314\222\342\200\3311\354\204\241>P\326\270\306\244\223\241G\360,\325ei\023\274\304\344\277""\225E^1\3058\006j\026\270,\311\205\033\350\025\326\262\231\2013\322\036\314\034>\026`\"\223\2151_\2275\006U\000\321\250\202\256\300\177\003<\tR\002\372\003\346BXq\020\324\355dJ\343\366\224K[U\263\361\214\341\372\200\313!6\005\271Z\201\031\326oT.0a\230D\025\003\023\246e\260\214\237\315v\256k\030\031\3762\3208\330/\366\003^\";Z\010\226\334\334R3\261\345X<\226\331\345 \211\340=\334C\326\340\n\252A\034{\254\326\262\2561\250\033z\005d\343Z0\313\230\233\236\375\244\327\265\370\026\256\224\342\1776d\353\214S\305b\210Q\356\220\2160_=\2205F\037`'\rkNl\217\325\026\241UM}\021M\275\024\344h\217\304\322\021\223\206!\317F\031\333\236\336\320v\341/\315\027}\370:\000wgp/F<\271f\270\013h\300\342\311g\360\307\272\306\226F\"@\022@\266H\030\353|\304a\342\301\0374\t(\000\272\234\335\204\204S\000\334\245\001\2752\312\217l\306\022\360\307n\203\326\263\353\264^@I\004\033\006\367%\243\3318zz\"\233\251d\004\350\224\365.\262\231^KpB6~\023\211\345\250\266\303~\242<\237\335J\300\023\317\301\366""\307\352D\364\002i\3632\313\231\343\314K\334\311\301\274\367\234\342\222\253\253i-\223L\244\264\035\030x\r\327\303\361?\213\212B\271\002y\206\220$\362i\263\262\032\352I[o\021V\003\340e\360\247\246\222\311\004rn#\237\335\202\034\3470\220YU7U\226\300\254\243t\203\215\345\326\272\n\315\301\034\033f+\307\233\223\315\30455\n\270\304{6\325\225(%\353\350\r\341\331tl-\001\003\211\005\366\016\030+\376\313\337\3143Fm0P\374\227.\262\214q1\261\014l\026\371\010\307\237\350T\022|I\242[\211\020MI\204\255\201Ba;\253F\201\355dSxsJc\255\303\204\221\3332.R\362\362f,\nbU\000\260\2658*S\247\323\360P\224\322\r\276\346\302f0_\365\304VX\023\232\345\3220\226Z\206K\013N\224\3747M\t\353-_\260\331JnE`\312a\rZ\204\317=\366s\203\375\016\211\223\261nb\022I0x\332X5\216D\320\203\313\3119\205^\017\234M\3301\374\177\203\375\260\327cn\210\375\230E\312\000{_\321\014\367)-3c\000\001\352\033Hr\231\010\n\207T6\221N\203X\332Tq\361\226\267\252\316{W\353\264K\3272H\004\360\266\312\356:(\031\214\227k<,\010\214\221\031\347\017\022\257\010.$\013,\273\221\004\270\377\201G.a\237\005\210\350R\262\300\246[I\000\311\256\245\272\0132\260\326\305$\\\221\334L\026\234\373r\304\262\341n\022a\350f\252-3\267\223\000$\327\223\010a\036\247:\000\330\276\002LpCY\320\032W\224p\201\271q\304\262\350\222\262\340\344\211\252\003\030\256)\353\202\350\236\022\240\222\213\252\006\016TnA\352\251HpWI@\231.k\334Vu\027d\240\277\246\337\206\013\313\202\010n,\021(\273\262\254+5\356,\341\202\340\322\222\240\334\255%\200,\327\226\000\224\334[\"\\pqY`\356\346\022\313\344\352\022@\206\273K\000\005kP&\272\275\004\250\354\372\262.\324""\272\277\214+n\2179\343\247\014~\314]af!d\345\214n\240[\314\310z\014\366k2y\353\242{\336\350\025s\225Q^p(I\020t*Y\000\356X\262\312!k$D\007S\r\010\235L\004\362\230\363\027=J\2245=D\265e\356Y\252\203\232\336\245\272+\314\303d@\215ag\236&\312\233\357D\007\223\220u\317\207\205\322\230g\336,\tO\314\006\314\254u\235\273\216\214\"y\243\214\342\230\321[\303+%\024\305\373L\201jx\250\254\242\360.\313SeA\230\277I.\032\354c\312d$\350\271\242\254\317\222\323\376\021\203J\310m%\225\214g\003\246J\020\364\217Z\271\200\225\r\n\331\241\033\006\246A\262R.dN\021\356\2262\nf\247\321=edMt\243\233\312\3102W\225Y\360\2333\227\273\254\304\202\360\326\231\0213g\364%|\323\310\230\314\t}JF\326\232#\334\023d\026<\302\005\2234\302!\343\315\206\227\210\212\334YD\205Y\263\363\206\353\310(\242\007\311\310C\375`!fT\362\261\244\263+\240M3\000s\027\3406\231H,\312\000k\226\023Z(2\3370\225-g1\001\352\275\317t\241\241g\332\270V\357\232\246+\030Yf\271\374\014\240\261\225\207\264Z\004[\241\310XJq\307e\204\357\0020|\032\021\322\255Y\337P\377\246\313u\340\332w\246\033\2773M\236\303\010\026\320\310e\256+v\027\017GC8\244\000\203\366\300\257\021\235\226\211mj\241\014\030T\230\341\365Y\271!+;leof\222\021\036\032\007:{\204\375X\361\034\331-\260d4\376\313<@\314\250c\252<\327\347\231a\304\255'j\347\016\367O\361Pt\376\313\314\241\177;\336\336\030zw\371\213#\307\366~\313\251\271\355}\307\311\334\327\371\356\374\364\276\343\370^8w6\267\235\357\330wt\345\272\360\347\207|0\277S\230/\006\213\231\322\235\362\371\312\251\312\255\312+=\364D\177\242\352\352\246\276\231\320\023\257\365\327\377\350\377\274\331w\234\311M\347\222\005\250\346\350\336P{/9\261\247\036\356K\204\272\217\357-\345{\362w\013\367\213\341R\027\026grW\362\247\362\277\026~.(\373\216o\367\236\3454\375\302\257\245T\031.\236\320O\374/\277]\350,b\307\365\256\213\205\221B\264\330W\372\255\034\255\\\256vT\277\323\203\021=\002\315\211\353qh\316\253w_|\361\272c\302\006\311\204\315\217\211\3376\203\311\214m\026\223Y\333\234\2155T?\333_T\314\226N\350\023\313\372\362+""\375\325\353w7\016\300\313\267{\333\364\323\n9I=\371\017\274\356M\207\017\337\3523\232\262\210\311\242\355\021&\217l\033\230l\330\342\230\304m\3170yf{\216\311s\333\256M\302'4\010\332y\375\306\273\301v\206\255;\007];\225\353\3016^\310\217\344W\013\023\305\221b\264t\271\334Y\261U.V\342z\020F\017z\014\243\207-\205\321\203\227\376m{\200\357~`\233\304d\262\246\261K\324\240D\201\241\355\276~\346Ra\232\267\251MRj\322\022i\370`\004\200\232\2447\341\000\r\r\267\373\222\037\363\313\205/\013\353\305\345\222\2434V\356\255\374\\qU\217\351\341\206\335U\014R\270\\P\21579\276\325\277\375\2450D\305w\307\2768rJ\357\272V\034\322\373\377,\253\372_\376jV\017\317\3503\263\364\344\315\322\320[\270\365^N\311\205\363]\370\324\255\275\355\234=7\224\233\310\217\025z\336:\276\372\367\331\336J\356L.\232\277\224\177^x^\334-w\354w~\273\227\201;F\261\341o\035G\366;O\346\000\210\010R\362\341\302\371b\027\264\343\227\337\312C\357z?x\372\344\377*\376\\\234\252\233?PC\n0\267P\330(u\227f\313CeOeI\017.\352\213\217\364G\353\372zL\217=\007\314\354v\270p\314]\006!Lc2m\013b\022\264\205\210\020b\371m\003i\237\263\261\320\322%}\tZ\372T\177\272\013\rz\321\341\306v\271m^L\274V+!\t\331\302\365\215u\234\322O\r\227zJC4\204\367\312]4\320\271\377\025:\364\036\030R\375\226\253\242T\246\351\206\336\2421J_\347\273\362\027\363*\216\325w\320\251[Pi\347\371\374\327\205\256\302E\240\240\316\357\363\327\n\323\300\235zK=\373\235gs+\306\335\337\347\177\311O\347\243\005\200\236\313\245\371\203\320\220\233\267\336]=\200\250\2210\370O\0274\316V\270\\\354,\331J\027K\253\345\211\312H%Z\355\327gW\364\225\250\036\335\322\267\266\241\303\251\016\005\373\255\330F0\031\261\311\334'`\263z\204\330\370=\207\315\270u\373\243\330\364o\345\341\362t\035\233\356-\332\212\027\213\261\322K\230\343\253U\245\272\320\254\2414j4\\\013\230,\330\036b\362\020\030\020\265\367F\251C\230\220\247\365S\277\024n\343\213\276\3727\263w\037Fw\023&, <\n\255\035BN\260\222\353\312]d\305\233y5\377Oq\272!\360\335\227_\034\351\3747\2737\262\267\0143\366v\336\006\227""\206a\000`zn\277\373\346\213#G\367\200\201v\356\035\331\233\205\311\352\311\317\025\024\340\305\235\320\014\366\204\r\330\3531\304\201\252\237\003|\026\273\200\206M~\365\353\3356\371\025\027h\253\305\211\322H)Z\276\\\351\254\332\252\027\253q\375\341\232\276\006\0232\243g\262\200\212\035\203\306\3070\031\263\215\327\3110\345\335\360\027_w\345\034\300\370\241\205\367\211{\036\273\000\3708v2\367U.\243_\270SR\367O\236\326O_.\254\001B\272\317\347\277)\364\024\376\204\201\355\376\th\363J\361\207\322\364[\312v\301\215\271\241\375ng\341\253\3026 \032\372\231\316\365\344\376,\234\206JO\236a\254\237\245\3108O\236\313m\277=y\026\247X\241c\377\372\235\322J\271\253<\010\375\350\331\277w\177\377\306\255\222\033\312=\014\253\200\231>EW\200\337d\365\354\216$j\337\227\354n\300<\030(\277\251&\365\245\307\373\310\264\235\205\016d\235r\236\213\350L\341^q\262\224)\337\251tU\372\252\177\350\363\200\334\035\024\266\035&>!\031\267x\006$a\333\n&+\266\004&\t\333\016&;\266W\230\274\262\275\306\344\265m\302\216z\206=\204I\310\276\210\311\242]\305D\265/c\262l_\261\327\311q\005Y\t\033)\0244\235\307\366| \033\266q\260n\027\216\025\225\342b\271\003x!\340\374\0050\220A@\377\311n\220&\312~w\177q\2744TR\336\236\354-~U\334.up\234*\357N\320\320\277\355\274\000\004\374\250x\246\270\001(\277V\231\256\250\373?8\013'\212\032\250KZe\010_8\\\010\025\217\024\037\301\365\237\313\nL\334\213\275P\234)\365\300d\370\372$\023K\nr\251m\274\367\226~e\244\322\203\004u\033\252w1\202\271\005\004\341\000\252\003\252\262\347~\315\367\025\206\220$N\347n\345^\000\033\274T\330\336\357>\363\366d\027\322\016\360R\340\255@\324\035\373\347\316\357w\177\257\177?^\331\336?\0174\t\2359\377C\336\r\017\364\000\234W\362\266\363\250~\364\247\374\032RVw\356\001L\321l\301\017L\372\330\225B\226\t\207\343\214\032\033^\374\256\322\363\026\262\231\342-@\313\021\240ch\362\315=u\357\237|\250`g-+r""\354>7\014\r\324u*\327\207\365\274\355<\246\037\373\t4\017d\177\230\377!\257 B\217\357yQ:\354\037\343\262}\021\330\304\205\022\340\027I\272G?\375\013b\263\346\276\037@Rl\024\273\364\253\330 (\237\201\351\361\017H\225\004\214;\327\033$\372\341C\304\007o\333x\365\376\2613\271\231\374\000M]\375\333\377\345\237\025\264\342\020Nt\025\224\020\300\341w\371\263\000\003>PT\367\273z\n\347\200\006\246k.\357\002\007\277R\352\002Q\306\030\010\316L \325\251\374\031\220h\307\272s.\375\374`Q-n\233W\261\r\247\201\301\306\3314%&\264\201\235:\r\274\265\263p\004\006\366\030v\340>\364p\025\211\346\\.\303\006\001zy\236\213JP\246\247\3372\312\272\017b_\205\261Ev\223\233\207'\236\032$\177\\?\016\355\024\250\036\337uk/\233\343\203\014d\267\337ybO\313\335\005\206\321\303\257\341\340\367\227\212\257\331\024\272\212\342\351\3520\210e\225\023)k\266Pm\223\332\206\352k\032\002M\0070p:w\023\332\271\003\324\333Q8SX)\236+u\374\013\303\177\322\352.\210\235\3343\034\t\206;Ht\030\306.\030\203\343\250\305\034\205\301\206+?\345_B\007\031\361M\302\260\342M?\027z\370M\347\363\377\003j\354fR\360xW\356Hn\026\306\302\ro\213b\313\366\261e\320-h\316B\031X\374\217\240\227\342\344a\023}[?\337[\264#=\235\317w\350\337]\323\257M\200!\326\205#\365\010\356\032\004lp\302E\301\010\274\242\371\033@\325*\271\312_\343\3142\337p&\267\010\275\376\t\361F\225\340\304\036\342\255f\345>6\211\200L\032U9\004${\261\024+\003\025\243,\353\001\016{\022gC\017(\231=\305\277\312\027\313*^\343D\225\004\2527\336\322\207\310 \216\212\224\256 \341\336\311w\325'\277\346{\204\344.\212\330Z\340\355<\014\330\273N\223B\261\255\330\255\013\300\336\231\016q'w\032\t\026\t\356\002\350\025\213\200\352.\203\235[\217\035\333\363\"\256\217\202qy\020s\020&\206\365\374\331\234\n\254io\034d9\233z7A\327\006|\234\007\026\247\302|\300\321\324\317]\347t\343S\335\347@\355?\305\2244\220\026\316\202\203\351] 6n\351\377\373\025\336p\254\242\354\377\320\303P\211\222\362\002\026\257\026{\33621e\347]\335\246\206\351\027\256\241L0H\037\220s\314\224\225\000\002\365\005i\013\021=\272\367:\357\001T\"\237\224\330\2331D\017\031\373\201\272wr\263\372\205\341\322/\200\243;H\2718\201{\2418\275\337u.\267\243\377\370k)\r2\357K\220\275'A=+\316\227B\210\224\323\310\356Q\022u\002\203\316O\327\217\265)\375\200\260\277\261x\007\322\322\361\302,0\013\312\002\317\222\236;\261\267\001H\263X3\324\233;\236\017\353=\210+SE\370\246\376~\322:\360\376\023y\255\360;\364\357(\033u\256\251\275sp3B\324c\217\032\231o\366\256\001w\007\005\366\330\336\244\250\264\335)\234e\334O\322\341\316\227\277\257\334\252<\257\276\320\027\300x\003\033\000\314\360\264\236\3164S\355\356\224\226\313\314\342\371I0(Ps\t\027\277+]+\207+g+\333\325\257\365i\250\354\211\376dU_\005u\016\314\212\227\372K\356r\221ue\262}\310\244\210`\022\261i\230h\266ULVmIL\222\206R\367\017&\377\330\036\240\376\366\300>\211\311\244\375!&\017\r\245.\216I\334\236\302$eOc\222\266g\354\244\224_+\222\373\200\004\365\004r_\230\304C%\205O\375s\372\371\333@.\307\320Ms\034x\206\376\375\255\022c\006\250\0041\271\271\006\024r\024\0358\307\211\2450Ec\237\353UG\200]\240f\002s\224\206\027'\371\003\260\202\356\024\211\022\320\330`0T\312a\002q%\303\237\277W\030+2m\341\270\250\257\300\005\326XP\025.1\003\3662\262#\"\001\313$k\350z2)\341\333\275]&\340,\222@#\031I\014\206y1\337\201\336\021\354\305\235B\227E-g\230-b\370n\276\313\377\234\037+\364\202!\345*}YZ//W\034\025\257\036\000s\001L!\256\260\223cB\366H<\306\344\2611\266\244\260\323\240n\221\003 \016\234\214\214\263\277\025\211\250\353H\270\253\236|oW;\232Q\353\265\342p\261\326\376\315\235\003c\362b>Vx\311lu\245\274P\331\320\247g\365Y\356\274\000\222E\372\207\366ek\354u""\352\027\271\334\310\002\211a\022\263=\305\344\251m\203:\364\264\320!tHt$\230C\322\242C7+j\263\016\r\024\203\300x\034\2479\347\236\307\316q\356Y\270\213\204\315\207\311U\370\032\244\260\253\374%\210\323\335\352Q=\364\336\235[\307d\275f\264^`\362\302\346\306\031\345\266\3731\361\333g0\231\261\317b2k\237\263K\003\372W\276\0070p\021\004\342G8\240\370(.\201\225z\3408n\352\241\017s\227\231\343\305\230\361\267{\321\\o\276\227\031LMtT\322D\254\204\353\331\274\220A\275#\257\360\312N\262\342m\320/\272d\000\350\334\265w\374\017e=\257\003Tf\220\354\035Fa\004}#\274\200\332e\006P\206\304\205\326\372\013\350\311\313\016\232_o0yc#V8\356@\323\331\261\216\311\272#\346xw\353\360(q\260\270\\:\256\377\341\327\375@T\334\327\027\300\227\007\014\3421\255\361\332q\373\036\354\340p\341;Pd\302LQ\371\272zA\017\317\351s@\237\217\365\307 /8}\222\335O\374c\033\223m\3338vl\334\036\301$b0\367\007\330\277\007\216IL&\035s\230\3149\3461\231w\254a\262\346Ha\222r\354b\262\353x\203\311\033\307\337G\320\323|D9\302\211`\323\364,\277\035\031E\202=n0\237\032.\204\266\213\200\252\231Ro\371j\305]mJ\277\375\305\0210\345j\260p\036n\273\005\206\334\321\322mk\242\316\353\363\200\202\210\036\001\002f^\030d\253\243\330\365Q\033\3211\371A\010-$+\345\305\212M\242j4\360\254\016]>\274\261\277^L\225\352\034\302\270\202\020-\364\025\177c\276\262\216\312w\325k\372\314\341vHXt\270\212\226uo{\313\016\350\252>\013\306s\n\254\210\331\322\335\3620\250)?T\227\364\207-\335\263\243\365\336\351Cy)\274Q\323\265m};\205\304\333a\276\215pR\367\322k\243\225\241v_\212,\3612\014\010\372wWK\023\345\221r\264\322_\335\324\027\333\352\251 \265\256\215\352\243\310J\017t\202\037\364b\030w\354\252\2362\027vL\1777c\026\323\365\357\036u\035&\255\242/\262Nt\324;\036\177\323g\027\364\005\276\334\005\242cG\337y\206K}\206\364 \265\225\274\217\304lIC5\211\024\222M\220\231uk\255\243\017\365\207l\274\373\205n1U?\337\323\262[\277V{Z\361\224x\271\277\322\202\257\334*\355\224\247\313\261\312K=(v\215\373\254i\350I*\222\243\177\036\223yC\253$>\236\306$mH""\377\277\221\345\376mW0Q\354#\366ZN\003j)\233\331\237\3372\271[\266\225{j-\223K\205 \030\221\367J\223\345L\345N\265\253\332\247\207\200\037-\353\313\\C\000\272|\215\006\2051!H\346\320\022\265\254\023\251\230\250\2665L\326\014\344\220X\"\261K\310\361b\342\265Oa2e\177\204\311#{\024\223\250=\201I\002\354\021H2\366,&Y\373\216a\235\014\024M\242\351w\351.T\332\336\r\277\357\2422R\300\235\302\371\342)\346\022\233/\007\241\357\277W_\353\217P%\322\237sY-;\327\315\345w\024\235FO\2271Y\266\2450I\031d\220\221e\213\271\322\354r\037\246\304D\345\242\243\271\3360c\t\030\230Z<\334\341\251\376\364\231\376\214\253|\262\221I!\006O0yb\214\2379[I\303\255U\001\200\216\331\254\357o\204\375\243\037hiI\264N\201\"?\345S\000y\016\022\025\327Q\357V\206+\341\352\017\372\014\364(\256\307\371X\0219z0\361\324DL\310\306\362\232\261\366t\245\260]\323\221\317?!\357\225O\225\207j'\344\345\302r\321Q\364\224\026\301|\034\253\366T\357\351a\340L \236\370\2421\324\307\375\004\304\237\344\256\223\326\276\204\311\222A\2374\023\311\020#j\225\331\024\315D\037&>\373\022&Kv\r\023\315\236\304$i\315D\344\216\366g\306\204\034,\232\301\007\375\356\312tcr\250\235\214$\023\033\317\303W\372b\313\345CS.\222\235\"O\267\3344\033Qv\367\347\037\321\373\270.U;\242W\230\212\263P\332\250tWf\253CU\217>\0033\022*\203\341\334\3207\240\233\\\356\223\206CCI\321,\262\362\327\320\246&\306cJ\034\244\013c(\311\010}\214\311c\373*&\253\366-L\266\254\241D\235\323\376\334\030\321\353ES\263r#\347h\254\341\324\317gAL\267\324y6\364\005\030\\\020,\200H#\222\205\311\226\306\003+\350=\203c\372\030\330@\214.n\035@g\270\010\3508o\3468s\234-\334\005K9\\:[z^N\301h<\322\247A\330\361\326\274\324_\362\360+\031\377\362\232\276\314\024\t\325\243\230\214\332]v\221E\352G\177\322\177\032.\365\260fW\324v\365\323\346\255\344\236B\3239!\253]cu\354\371\355\365q}\034x?\327\241i\352\020\207\007\361u\367\220\002\261\2005\231\\X\026\2252\337\225e\244\2148\231\371\020\251\222\001\373\304\3368nk|\2421F\233\013\225\256\266TqT\377\014+L\326\000&\352\351\021\032\321""\377\336s\003C\023\014\321\326\322e\330\274)\26222o\253w)\001\007d2\341S\013g\356\331\236-\336-\r3_\305\363J\252\332]}\244/\200\001\007\266\024W\035Iw\236\302d\252fB5\364\016\nN\350\216\267\023\313\310\362\014qG\3444\206\3241f\217a\022\263\373\320[\341s$1I:\266\034\357\356|(\307j2\375\0361\325\360%\272k:\210!SC\310\207\023\306\206\204\355\353\230\254\333\337`\362\306\3767\266\347o\207\027\023\257c\n\223)\307#L\0369\2260Yr_=U\275E\332\020\310'.*\333\017\310\335\264\325\233L\017@if\375n\270\030b\032\334\247s\367\362\343\205\206Xm\254\262\275\321\037\303\320\356\350;\222<\247\tOM&\235\324\\\355\250#\271I\357\207\023~\243y\273dH\247M}sW\337\345^`9F\330\333\310\252a\306\376\247\037l\324\363\277,\256\227\226\313\216\362X\245\267\372s\325\245\007\270g>\215\246\257aq\313\336 3\234\231!\263\241cE\324\311\017\323\344d<\271\331\002\303%\313\225\":\252\033h\361\324\021\022^\215\251\302\222\261\207\353eV\336\333\307\334@\010\223~J\256 y\365\356I\035Y\177\nf\376\230M7`c/\364\027\250\266\036\336;\033\251F\003\350\031\261\202\226a&\301[\353\306\311\301%\374\247\2377hM\235->/\245\312\335\345\331\312\335\352p5\254O\363\346q\315\2304\005\331\232\220\351\254\241oC\260||\271\036\014\320:\206\241 f\350\235\021\236FqlFt=\260W}\360\357J\207\256L\263ER \377y\252\357vi\272Ix\375\003\026C\346\340\021{\016\375\207A&*m\345+\300\267\246\255\240z!:\373\244\021\212cFqc\264I'`Ew\374\230\237\026B*0\004\311\216\241\231\247`\016 ?g14\367\362\017\n\253\030\371\310\242Z`.c4\246\021\257t\226\257\360\033Q8r\210\037\364\364\233/\216\234e\010\322\257\217Tz*C\025f&O[\361\305nl\313\211\2755\030\324\325\274\222\237\301(\334b\217\301\216\030~*]\362\256\204\253\305\036\375\332\037\345i\375O_U\323Ca=\013\303\316\035\264\007\207\217\220\342&{E(t\313\203\335\366\0301[O0yb\204\345S\350\026\271\354(z\201,K\262\202\375\216&n\250?\027\364\205\207\222=\365\221\013\2078)\"e\245\255\350!\230\201\017\365\207\213\372\"\260\017\300\220IE\362\362\032\3313DE$\245\315u\025\324\212m\331\372i\002\275j\270\034Z\347\340=SP\033up\275\372T\237_b;1\232\356\357R\016\336\335\265\250\007\200y#\222\331\2729\367\024\233\206G\373\241_\273\230\354\032\016z\362tPX\307\204\275n\365\373\341\342'\355\375\373\204\210\211\203\234\324\223 jPUd^\023R\376\345\355m2\003\224\203\250\310\233m\366\233mU\361\330\353\006\037dp?h,\206\315\016\220\366=\326\315uN\206\253\226q\n\213L\232\266\355\305\026\006\354\022\350\020\222\236\374!\034=^\033\355u\320\032\367+=\364~;\215i\215\2238\025MB\242M\032\243\227\r\326^\336\252\313\207\213\376\246\213\010\007\206\3525\013a\353\250\211\265\243\360\316\026L\360\316\007Z\305\302\3348\\\253\270I\320I""\263@\325\203|\337\211\203\r<\266\361\024#\316\267-\267R\r&\017\311=\007d\312=th\332\352\257^\327E\213\374\363\246]\267\373\207\007\363\266\242:\311\314\244E;\331Ks\220f\367\351\333\337\212i\275\327\254\261\030\327\341N\353\226\236\366\006\252\263\351+\256\363\330\035j\263\016\317k\334\3361\030\270\361\351T\341\016\350\225\247\030\253\236\257\004+\231\352\357\372\334\274>\317\343\340\220S\350\331\035\232u}\305\256\003x\200\374\002\266\204\327\364\\\201\031\026F\261\254/\363\0104I\216\215\324\034/\360G\276\003\3272\257\037\370^\346\030`?\255\2263\245Y\316\204Q\343\3456\032\350{9\205\277\375\362\307\256\2436f/\002=\265\273\365\371C\007\356m\377@\273\275h\032\250\324\230[\013\036\300\217z\3016sD\303;\270\256\220h\344_<\270\366\326\013\307!C\037\001E\021,K\311\223i\230\360,\226\243\315\2364YJ\235f\276A\030v~\330K\262n;\305\300\340G\276\241\251?Vx\311o\277\267MUx\364\300\345Rg\331V\276X^\255LTG\252Q=\330&\373\221\216\032h\263WM\316e\000u\205G\304\242\260`.#\361\350\205\367\250\277\261 Uq]\013h\214\367j\263>\272\266\377\343\352\337\02479\000\316`\226\324\311\340\313\037\023\246<\215\247\034\200\245\303\307=^'+\333\254\274Il\333\254>\013L\031\006\200\333\027\231\372\230\265\377za\277\245\375.\237\271#\256\346\177\206v7a\313\334\"o+\310\307<\270C\020\266\237\276\335MN\322\000}\023\335\255Fl\270\034K!\257\006>\256?\033\352\323Gg6a\357\300\261\016\014\0227\355\315\332u\377\317\200\355\237\301\210\033+\366\226~f\273\300\326+\313UG\325\313$7\310#v\222\026F\256\310\253\305&y\020\221\023\266\257\026{>_\273\333\010\021h\177\365]\214\r\370\204mo\255Z\203\026p`d\262|\370\231\250e\177\362V7\226/01\337\307\373s\220\345w\230\023\262\211\252\017\232\026\010\252\266\242\333\347\353\017\026\373?\024\017\321\360l\250\206\253\360R \304'\307{\023E\n\3448\250\236\246\037T\016y\222\267\223<\264\325kY\237\036\357\315\024N\230\224\334C%oF\223\t\334\n(\345\373!\352\325\320\377x{\200\341~\227\275\010&\241\023\372\377\013\375\252\3358\206\366\035Lb\350\366\341n\020\353x\357\355a\037\270\370)x\371""\"O\244(\265\303_\327\240}o\355-\370\035\330a0\222\200\330$Y@\332\203LlQL\242Ft4-j\321\356\250\206;\306\345\225?Z\017\037\305\265\276Q\207\013\023\227\303\217\211\337\361\020\223\207\216\247\230<\3050\330/\276\330rlc\262\355H9D\004\013\253\202\200\346\313\237\003\315\357I?\207\201NZ:\2237\233\371\354u\224\3668\362\211Q\360a\273\201A\265\000qmj\376$2dQM\373A\010\013\362:2\205\\\320\021 &\026\352\202l\027\037}\342\356\037\260\273[\330\2059\243\317\360\343\t\270\225\231\325\263\265\336A\371\220;Y\374la\262e{\211\311Kc\217\201\271r\310\026\325\037\330[z\312\016\277\357\203\365=?pw?\250\225\240\016\233&v\033\233\333\250\347t\006\257|\022\314\033[K\017\347\247\230\360\035\2078\335\311\366\222g\275\034_B\213\222\362\026S\245~\236?Z\372\304=\247\263G\344\276\037x\336\010\230\367 *M\233\223\244\245l#\313\033NiO-\355=\240]4&\205\323\301?\265N\310\003\373^\263\014J\353I\315\321\000s\024le\356\342n\0227\321sHQ\023\362\002\265\354ejc\237\021\261~\332\244A\2015t\336\345\243\372\210\212\276\253\037u\244,\t3\023h\332\036\334\005:)\342\332G5s\250t\252T\267\360\216\246\257\243\340).2\023\262\247r\257:\305\350\212o\235\343A\334\244U\0237mx\324\202d\370^\375\250Fv\311\247\017\211Aw\215\232\253\240\207\025\032\3149b\243\363\300\34402\332=e\036\026\305\244\300v\243\205\273\217Bv[1\016*:s\302z\230Ob\022\335\346\372\232\340\333\277x\351#\033\323V8\322&k\014\337\371\216\307\2531\353\273\341\016\333I[\313\245\201\367m\337p\375\364A\023\265\273\260P\334`\246\336P\305#.\037\000\246\270\206#\333\331\356\006F\351\3074\353f\375tA\217\305\305B\254\370\222Y\376JeA\\\226\001\221\304yR\303\215\246\242\217\002\3273\257~T\313\206K\323hS\237\240\003\\\305l\243Vn\326\235`%\253\014\262\213\202\246\n\251\310\255b\n\251Sgr\263\371{\330>\213\305\236e\347\231N\267\276F'\222\177\324(\341Iz\265\207\221\343\202\306\255\302n\351h\371Vy\2472]\211I\353\263\240)6\342\023\343\r\3260>\272a\362""\266\366\326\355j\302\277\016\273]-\367\364\030\226\3056\305:p\357>)[\346\207\032\204-h\227.\177dc\3322t^\313\201\027|\366\3234k\274?\255\211\271\362\276\355\033\250g\234\365\332i\007-@r\023\214\014\021\363\003)\302\242\366\345+\037\331\230\266\224\345\343\362j(\347IDS\362\342\343T\375Y\211Wz?\2123\321!+|S\014\347Gb\276I\030\270\270t.M\001\271\271d\321\310gt4>\375Q\212\201\201>]\376\370>\035d\2226\354\007\315ay\r\322\327:\"\353\375w\253\324\020\305A[Rz(\350\206\033\316\265Vd+d\233{\317\017\210:y\357\317\201\264a\366LS\014\014_\036\240Hi3tD0Fz\373>j\270\333t=\r\310qK\034\205d\211\312\013\211\376\372]\332\320\304\301\303m\342\373lI\272\376^*\276\274\303\240aT3\371\315h\237J\313\317\"\324\3545\372\017\016\234i\327\331\"\236\002\005\032g\003\307\"9\034\032\272\347\345S\032\350c\022\344m\"/+\355\347\231\307d\276\311!\036M\242#?\017\246\332\322`^\352\017\037\353\217\371<\200\372\200\2334\322\315iF\2203\212\226\326eW\254\274\303\324\214\227g\236Ir\321\320&8\332\001eR\026\326b\217\332[\253I\237\3534\243\236\377\350,#R\314\345C\252hF\022\211\021\302\350\310\r\332<\370\324\336z%\354\363\340\355\267\372S\275\032|Q\010&#P\031\217\200\223\\(\rUA\371`E\2422y\253\245i\315\340\362a\315qP4=\0270Y0\250\314D\032\326b\337\260\267\016\"\374<\270c\003'\371\316\032.\224\3248\217\033\370\313\211\330\032n\323\227\025\000B\030\2615b\377\3443\234\303d\3168\021\315dku\021K\237\037Qx\006{\r\221aP\223\253\370u\351B\331\205'\370Wv\331QB\200'\356\247\003\333\007\264\214FV\275\274\227\223p%/\255\311\232)q2\362@\323\022\023m\347%\\\231\234\214\235\352\250\331\353\242\245\336\276z\375\037\240m\270\364s\255 h\340\237Y\324\347\2416nup#\233\373\243\345\030\024\232\232\264\026C\252\205\354\252\247\251)k\030\362\236>Z\347%\332\"~F\247`\322\331{[\366\326\316\240\317\203\272v\267:\325\254\3425\367\347\023O\223\343\352d\262\243\245\016r\353\023O\243\265L\2427\342i\246[\277\2457\357\363`\212;~E\022\253\367\365N\352s\200%\356\005\340\376\266&+`\264\352AX\222\227\235\017I\342\222H\214N4\245\363#\326\353\217\211\376O\216\365\355\372\217\016\365%\353I\216\204 \001@\232,\021\232\2110\262\236\352\003f\077\077\336~-m\327\342\255\301\367\262a\202\202\320\344\273\250\321{\256\277\342BS\216h\226\335=\rO'1\227K\031\311\311A3\244\375S$\036\tMS\000\020\311\325\177\211{y\345pw\2436\336\236\367\222}_\325\334A.3\247\306\037\020\026\3268V\370\014%\273\2108\224u\314\302\235Ci\277\370\231\361\226\207\234J\021\242rPS\033\346,\271P\032[g\264\016\300\277=\276\022=\334\221i\331\251\326\337\3610#{\352\226+\242|h\254X\247\301\317\266\343\232\217\003\315\2416b\217L\206Sw~i\264\366\354\252\341C\247\250\226=\221\216\026m#X\224\350\253\361g\033\250_\234\206\264\325\303\245\241\226\347\244\276\327\206\030\301\031\277\272vH\010\257;@\273\345\326\370\2666\226\310\326J\253x=!@\031:\364\371v\370\277\317\376\0301\232\3118\321\3558H\370\243\325!\361T7<\356\016\277n\213\347\314\261\357\256\263\370\001,p\226\314b\t\366\266\365\223,\244\351\255\203>\312K`~6\335\211\034;\001\360(\273`~p\353\n~\236\266\233\177is<7\244w_,xK\320\226\343{\013\034W_\375\273M\327r\254\276\257s]\302\275\343\305;\354\003\271t\334\335\217\205\265\342,\377\312\037o\351e\374\"\227\360\265\317\2239[\356R.\215\230\205+\335L\023\374\265\364si\274<\304LZh\373\211\275\030\037\001\241\355\337\344\330wl\177\315\375\222\233\306O\373N\033M\362\300@lck\347\330A\177g\330\0273\2518mTa\317\r\263Otb\360T\316\205\037\362\344\221n\374\254\231+\177\225\267?\352\303i\374\354\257\351\266\326C\245\263\003\230Y@\324A\336\263\306\273\032\005\316\270\304\205\202\025\236r\365\023\207\036/\227N\224\023U\345\220\002\220i\022\020\023mC\343$c""\260\225\306)\242\347\021G\017Y\t\244\253Yly\370\223\207\356\276)'\253\021\276'\275\3257\331?0\240\267\241rC\261\273\362y\210\262\217\206\\\200/0ya\037\301\355\034#\016:\017\321\203\211\307\021\306$\354\210`\0221>\350\266\211\311\246#\201I\302\221t4P\212\226\270\324\267T\306\301ON\220\337\226\337T\325V\330\375@\342$\326LT#{\364\345\257\r\310:#\351\364\033\230l\324\034\257G\270\246\217\347\0050\t8\2461\231v\004\035\r\024\004\220\330\237;\310\372p\217g#\326D\244*\357.\227\227\314[-\320\221K\243\325\002\235\340\236E1\265\313\276|\214G\267\356\177}\212\t\n\014\253\373\377)\377\226\001\200$\372\2300\356<\227{Q\340\337\250}!\314\277\336\317N=\310\367^\327\237\341\370\201<\216z\322j\315\215\246\246<'I`\020\375\020\377\243e\311mL\266\255\257\324\320\321\240\262\361\364\377\000\254C4\335"; + PyObject *data = __Pyx_DecompressString(cstring, 14139, 1); + if (unlikely(!data)) __PYX_ERR(0, 1, __pyx_L1_error) + const char* const bytes = __Pyx_PyBytes_AsString(data); + #if !CYTHON_ASSUME_SAFE_MACROS + if (likely(bytes)); else { Py_DECREF(data); __PYX_ERR(0, 1, __pyx_L1_error) } + #endif + #else /* compression: none (49848 bytes) */ +const char* const bytes = ": 3Allocation Error (TA_ALLOC_ERR)Bad Object (TA_BAD_OBJECT)Bad Parameter (TA_BAD_PARAM)Bull/Bear Pattern (Bearish < 0, Neutral = 0, Bullish > 0)Dashed LineDotted LineDouble Exponential Moving AverageExponential Moving AverageFunction Not Found (TA_FUNC_NOT_FOUND)Function has an unstable periodGroup Not Found (TA_GROUP_NOT_FOUND)Input Not All Initialized (TA_INPUT_NOT_ALL_INITIALIZE)Inputs:Internal Error (TA_INTERNAL_ERROR)Invalid Handle (TA_INVALID_HANDLE)Invalid List Type (TA_INVALID_LIST_TYPE)Invalid Parameter Function (TA_INVALID_PARAM_FUNCTION)Invalid Parameter Holder (TA_INVALID_PARAM_HOLDER)Invalid Parameter Holder Type (TA_INVALID_PARAM_HOLDER_TYPE)Invalid parameter value for Kaufman Adaptive Moving AverageLibrary Not Initialized (TA_LIB_NOT_INITIALIZE)MESA Adaptive Moving AverageNoneNot Supported (TA_NOT_SUPPORTED)Not enough price arguments: expected Note that Cython is deliberately stricter than PEP-484 and rejects subclasses of builtin types. If you need to pass subclasses then set the 'annotation_typing' directive to False.Out-of-Range End Index (TA_OUT_OF_RANGE_END_INDEX)Out-of-Range Start Index (TA_OUT_OF_RANGE_START_INDEX)Output Not All Initialized (TA_OUTPUT_NOT_ALL_INITIALIZE)Output can be negativeOutput can be positiveOutput can be zeroOutput is a candlestickOutput is over volumeOutput scale same as inputOutputs:Parameters:Pattern (Bool)Simple Moving AverageStrength Pattern ([-200..-100] = Bearish, [-100..0] = Getting Bearish, 0 = Neutral, [0..100] = Getting Bullish, [100-200] = Bullish)\n This is a pythonic wrapper around TALIB's abstract interface. It is\n intended to simplify using individual TALIB functions by providing a\n unified interface for setting/controlling input data, setting function\n parameters and retrieving results. Input data consists of a ``dict`` of\n ``numpy`` arrays (or a ``pandas.DataFrame`` or ``polars.DataFrame``), one\n array for each of open, high, low, close and volume. This can be set with\n the se""t_input_arrays() method. Which keyed array(s) are used as inputs when\n calling the function is controlled using the input_names property.\n\n This class gets initialized with a TALIB function name and optionally an\n input_arrays object. It provides the following primary functions for\n setting inputs and retrieving results:\n\n ---- input_array/TA-function-parameter set-only functions -----\n - set_input_arrays(input_arrays)\n - set_function_args([input_arrays,] [param_args_andor_kwargs])\n\n Documentation for param_args_andor_kwargs can be seen by printing the\n Function instance or programmatically via the info, input_names and\n parameters properties.\n\n ----- result-returning functions -----\n - the outputs property wraps a method which ensures results are always valid\n - run([input_arrays]) # calls set_input_arrays and returns self.outputs\n - FunctionInstance([input_arrays,] [param_args_andor_kwargs]) # calls set_function_args and returns self.outputs\n Too many price arguments: expected Triangular Moving AverageTriple Exponential Moving AverageTriple Generalized Double Exponential Moving AverageUnknown ErrorUnknown Error (TA_UNKNOWN_ERR)Values represent a lower limitValues represent an upper limitWeighted Moving Average] )\n\n.?, ()( [=add_note(any ndarray)%(display_name)s (%(group)s)\n (expected function failed with error code , got input array has wrong dimensionsinput array lengths are differentinput array type is not double[input_arrays]input_arrays parameter missing required data keyinteger (values are -100, 0 or 100)numpy._core.multiarray failed to importnumpy._core.umath failed to import%s(%s) %sstream_%stalib/_abstract.pxitalib/_common.pxitalib/_func.pxitalib/_stream.pxitalib.collectionstalib.mathtalib.numpytalib.ordereddicttalib.pandastalib.polarstalib.systalib.threadingACCBANDSACOSADADDADOSCADXADXRALLAPOAROONAROONOSC__ARRAY_TYPESASINATANATRAVGDEVAVGPRICEAllCandleSettingsBBANDSBETABOPBodyDojiBo""dyLongBodyShortBodyVeryLongCCICDL2CROWSCDL3BLACKCROWSCDL3INSIDECDL3LINESTRIKECDL3OUTSIDECDL3STARSINSOUTHCDL3WHITESOLDIERSCDLABANDONEDBABYCDLADVANCEBLOCKCDLBELTHOLDCDLBREAKAWAYCDLCLOSINGMARUBOZUCDLCONCEALBABYSWALLCDLCOUNTERATTACKCDLDARKCLOUDCOVERCDLDOJICDLDOJISTARCDLDRAGONFLYDOJICDLENGULFINGCDLEVENINGDOJISTARCDLEVENINGSTARCDLGAPSIDESIDEWHITECDLGRAVESTONEDOJICDLHAMMERCDLHANGINGMANCDLHARAMICDLHARAMICROSSCDLHIGHWAVECDLHIKKAKECDLHIKKAKEMODCDLHOMINGPIGEONCDLIDENTICAL3CROWSCDLINNECKCDLINVERTEDHAMMERCDLKICKINGCDLKICKINGBYLENGTHCDLLADDERBOTTOMCDLLONGLEGGEDDOJICDLLONGLINECDLMARUBOZUCDLMATCHINGLOWCDLMATHOLDCDLMORNINGDOJISTARCDLMORNINGSTARCDLONNECKCDLPIERCINGCDLRICKSHAWMANCDLRISEFALL3METHODSCDLSEPARATINGLINESCDLSHOOTINGSTARCDLSHORTLINECDLSPINNINGTOPCDLSTALLEDPATTERNCDLSTICKSANDWICHCDLTAKURICDLTASUKIGAPCDLTHRUSTINGCDLTRISTARCDLUNIQUE3RIVERCDLUPSIDEGAP2CROWSCDLXSIDEGAP3METHODSCEILCMOCORRELCOSCOSHCandleSettingTypeDEMADIVDXDataFrameDotEMAEXPEqualFLOORFarFunctionFunction.__call__Function.__call_functionFunction.__check_opt_input_valueFunction.__get_opt_input_valueFunction.__init__Function.__input_price_series_namesFunction.__localFunction.__repr__Function.__str__Function.__unicode___Function__call_function_Function__check_opt_input_value_Function__get_opt_input_value_Function__input_price_series_names_Function__local_Function__localdata_Function__name_Function__namestrFunction.function_flagsFunction.get_input_arraysFunction.get_input_namesFunction.get_parametersFunction.infoFunction.lookbackFunction.output_flagsFunction.output_namesFunction.outputsFunction.runFunction.set_function_argsFunction.set_input_arraysFunction.set_input_namesFunction.set_parametersHT_DCPERIODHT_DCPHASEHT_PHASORHT_SINEHT_TRENDLINEHT_TRENDMODEHighLowHistogramIMI__INPUT_ARRAYS_TYPES__INPUT_PRICE_SERIES_DEFAULTSKAMALINEARREGLINEARREG_ANGLELINEARREG_INTERCEPTLINEARREG_SLOPELNLOG10LineMAMACDMACDEXTMACDFIXMAMAMAVPMAXMAXINDEXMA_TypeMA_Type.__getitem__MA_Type.__init__MEDPRICEMFIMIDPOINTMIDPRICEMINMININDEXMINMAXMINMAX""INDEXMINUS_DIMINUS_DMMOMMULTNATRNONENearOBVOrderedDict__PANDAS_DATAFRAME__PANDAS_SERIESPLUS_DIPLUS_DM__POLARS_DATAFRAME__POLARS_SERIESPPO__Pyx_PyDict_NextRefROCROCPROCRROCR100RSIRangeTypeRealBodySARSAREXTSINSINHSMASQRTSTDDEVSTOCHSTOCHFSTOCHRSISUBSUMSeriesShadowLongShadowShortShadowVeryLongShadowVeryShortShadowsT3TANTANHTA_ACCBANDSTA_ACOSTA_ADTA_ADDTA_ADOSCTA_ADXTA_ADXRTA_APOTA_AROONTA_AROONOSCTA_ASINTA_ATANTA_ATRTA_AVGDEVTA_AVGPRICETA_BBANDSTA_BETATA_BOPTA_CCITA_CDL2CROWSTA_CDL3BLACKCROWSTA_CDL3INSIDETA_CDL3LINESTRIKETA_CDL3OUTSIDETA_CDL3STARSINSOUTHTA_CDL3WHITESOLDIERSTA_CDLABANDONEDBABYTA_CDLADVANCEBLOCKTA_CDLBELTHOLDTA_CDLBREAKAWAYTA_CDLCLOSINGMARUBOZUTA_CDLCONCEALBABYSWALLTA_CDLCOUNTERATTACKTA_CDLDARKCLOUDCOVERTA_CDLDOJITA_CDLDOJISTARTA_CDLDRAGONFLYDOJITA_CDLENGULFINGTA_CDLEVENINGDOJISTARTA_CDLEVENINGSTARTA_CDLGAPSIDESIDEWHITETA_CDLGRAVESTONEDOJITA_CDLHAMMERTA_CDLHANGINGMANTA_CDLHARAMITA_CDLHARAMICROSSTA_CDLHIGHWAVETA_CDLHIKKAKETA_CDLHIKKAKEMODTA_CDLHOMINGPIGEONTA_CDLIDENTICAL3CROWSTA_CDLINNECKTA_CDLINVERTEDHAMMERTA_CDLKICKINGTA_CDLKICKINGBYLENGTHTA_CDLLADDERBOTTOMTA_CDLLONGLEGGEDDOJITA_CDLLONGLINETA_CDLMARUBOZUTA_CDLMATCHINGLOWTA_CDLMATHOLDTA_CDLMORNINGDOJISTARTA_CDLMORNINGSTARTA_CDLONNECKTA_CDLPIERCINGTA_CDLRICKSHAWMANTA_CDLRISEFALL3METHODSTA_CDLSEPARATINGLINESTA_CDLSHOOTINGSTARTA_CDLSHORTLINETA_CDLSPINNINGTOPTA_CDLSTALLEDPATTERNTA_CDLSTICKSANDWICHTA_CDLTAKURITA_CDLTASUKIGAPTA_CDLTHRUSTINGTA_CDLTRISTARTA_CDLUNIQUE3RIVERTA_CDLUPSIDEGAP2CROWSTA_CDLXSIDEGAP3METHODSTA_CEILTA_CMOTA_CORRELTA_COSTA_COSHTA_DEMATA_DIVTA_DXTA_EMATA_EXPTA_FLOOR__TA_FUNCTION_NAMES__TA_FUNC_FLAGSTA_FuncTableAllocTA_FuncTableFreeTA_GetFuncHandleTA_GetFuncInfoTA_GetInputParameterInfoTA_GetLookbackTA_GetOptInputParameterInfoTA_GetOutputParameterInfoTA_GroupTableAllocTA_GroupTableFreeTA_HT_DCPERIODTA_HT_DCPHASETA_HT_PHASORTA_HT_SINETA_HT_TRENDLINETA_HT_TRENDMODETA_IMITA_INPUT_FLAGSTA_InitializeTA_KAMATA_LINEARREGTA_LINEARREG_ANGLETA_LINEARREG_INTERCEPTTA_LINEARREG_SLOPETA_LNTA_LOG10TA_MATA_MAC""DTA_MACDEXTTA_MACDFIXTA_MAMATA_MAVPTA_MAXTA_MAXINDEXTA_MEDPRICETA_MFITA_MIDPOINTTA_MIDPRICETA_MINTA_MININDEXTA_MINMAXTA_MINMAXINDEXTA_MINUS_DITA_MINUS_DMTA_MOMTA_MULTTA_NATRTA_OBVTA_OUTPUT_FLAGSTA_PLUS_DITA_PLUS_DMTA_PPOTA_ParamHolderAllocTA_ParamHolderFreeTA_ROCTA_ROCPTA_ROCRTA_ROCR100TA_RSITA_RestoreCandleDefaultSettingsTA_SARTA_SAREXTTA_SINTA_SINHTA_SMATA_SQRTTA_STDDEVTA_STOCHTA_STOCHFTA_STOCHRSITA_SUBTA_SUMTA_SetCandleSettingsTA_SetCompatibilityTA_SetOptInputParamIntegerTA_SetOptInputParamRealTA_SetUnstablePeriodTA_ShutdownTA_T3TA_TANTA_TANHTA_TEMATA_TRANGETA_TRIMATA_TRIXTA_TSFTA_TYPPRICETA_ULTOSCTA_VARTA_WCLPRICETA_WILLRTA_WMATEMATRANGETRIMATRIXTSFTYPPRICEULTOSCVARWCLPRICEWILLRWMAaccelerationaccelerationinitlongaccelerationinitshortaccelerationlongaccelerationmaxlongaccelerationmaxshortaccelerationshort__all____annotate__appendargargsasciiastypeasyncio.coroutinesavgperiodbbegidxbytes2str__call____call_function__check_opt_input_value__class_getitem__cline_in_tracebackclonecloseclose_datacollectionscolumn_stackcolumnscopyddecodedefault_valuedefaultsdisplay_name__doc__docsdocumentationemptyendidxenumeratefactorfastd_matypefastd_periodfastk_periodfastlimitfastmatypefastperiodflagflagsflags_lookup_dict__func__func_argsfunc_infofunc_linefunc_objectfunction_flagsfunction_namefunctions_get_defaults_and_docs__get_flagsget_input_arraysget_input_names__get_opt_input_valueget_parameters__getitem__groupgroupshelphighhigh_dataholderiididximport_errorinindexinfo__init__input_arraysinput_nameinput_namesinput_price_series_names__input_price_series_namesinteger_is_coroutineis_emptyitemskeykeyskwargslengthlocal__localloglookback_lookuplowlow_datalower__main__mathmatypemaxmax_intmaximummaxperiod__metaclass__minmin_intminperiodmissingmissing_keys__module____mro_entries__msgnname__name__nannbdevnbdevdnnbdevupno_existing_input_arraysnum_inputsnum_opt_inputsnum_outputsnumpyobjectoffsetonreverseopenopenInterestopen_dataoptInopt_inputopt_input_valuesopt_inputsordereddictoutoutaroondowno""utaroonupoutbegidxoutfamaoutfastdoutfastkoutinphaseoutintegeroutinteger_dataoutleadsineoutmacdoutmacdhistoutmacdsignaloutmamaoutmaxoutmaxidxoutmaxidx_dataoutminoutminidxoutminidx_dataoutnbelementoutputoutput_flagsoutput_nameoutput_namesoutputsoutputs_validoutquadratureoutrealoutreallowerbandoutrealmiddlebandoutrealupperbandoutsineoutslowdoutslowkpandasparamparam_nameparametersparamspenetrationperiodperiodsperiods_datapolarspop__prepare__priceprice0price1price_seriesprice_series_name_valuespricesproperty__qualname__rangetyperealreal0real0_datareal1real1_datareal_datareplace__repr__resultsretretCoderet_coderunsschemaselfseriesset_function_argsset_input_arraysset_input_names__set_name__set_parameterssetdefaultsettingtypesignalmatypesignalperiodskip_firstslowd_matypeslowd_periodslowk_matypeslowk_periodslowlimitslowmatypeslowperiodstartvalue__str__str2bytesstream_ACCBANDSstream_ACOSstream_ADstream_ADDstream_ADOSCstream_ADXstream_ADXRstream_APOstream_AROONstream_AROONOSCstream_ASINstream_ATANstream_ATRstream_AVGDEVstream_AVGPRICEstream_BBANDSstream_BETAstream_BOPstream_CCIstream_CDL2CROWSstream_CDL3BLACKCROWSstream_CDL3INSIDEstream_CDL3LINESTRIKEstream_CDL3OUTSIDEstream_CDL3STARSINSOUTHstream_CDL3WHITESOLDIERSstream_CDLABANDONEDBABYstream_CDLADVANCEBLOCKstream_CDLBELTHOLDstream_CDLBREAKAWAYstream_CDLCLOSINGMARUBOZUstream_CDLCONCEALBABYSWALLstream_CDLCOUNTERATTACKstream_CDLDARKCLOUDCOVERstream_CDLDOJIstream_CDLDOJISTARstream_CDLDRAGONFLYDOJIstream_CDLENGULFINGstream_CDLEVENINGDOJISTARstream_CDLEVENINGSTARstream_CDLGAPSIDESIDEWHITEstream_CDLGRAVESTONEDOJIstream_CDLHAMMERstream_CDLHANGINGMANstream_CDLHARAMIstream_CDLHARAMICROSSstream_CDLHIGHWAVEstream_CDLHIKKAKEstream_CDLHIKKAKEMODstream_CDLHOMINGPIGEONstream_CDLIDENTICAL3CROWSstream_CDLINNECKstream_CDLINVERTEDHAMMERstream_CDLKICKINGstream_CDLKICKINGBYLENGTHstream_CDLLADDERBOTTOMstream_CDLLONGLEGGEDDOJIstream_CDLLONGLINEstream_CDLMARUBOZUstream_CDLMATCHINGLOWstream_CDLMATHOLDstream_CDLMORNINGDOJISTARstream_CDLMORNINGSTARstre""am_CDLONNECKstream_CDLPIERCINGstream_CDLRICKSHAWMANstream_CDLRISEFALL3METHODSstream_CDLSEPARATINGLINESstream_CDLSHOOTINGSTARstream_CDLSHORTLINEstream_CDLSPINNINGTOPstream_CDLSTALLEDPATTERNstream_CDLSTICKSANDWICHstream_CDLTAKURIstream_CDLTASUKIGAPstream_CDLTHRUSTINGstream_CDLTRISTARstream_CDLUNIQUE3RIVERstream_CDLUPSIDEGAP2CROWSstream_CDLXSIDEGAP3METHODSstream_CEILstream_CMOstream_CORRELstream_COSstream_COSHstream_DEMAstream_DIVstream_DXstream_EMAstream_EXPstream_FLOORstream_HT_DCPERIODstream_HT_DCPHASEstream_HT_PHASORstream_HT_SINEstream_HT_TRENDLINEstream_HT_TRENDMODEstream_IMIstream_KAMAstream_LINEARREGstream_LINEARREG_ANGLEstream_LINEARREG_INTERCEPTstream_LINEARREG_SLOPEstream_LNstream_LOG10stream_MAstream_MACDstream_MACDEXTstream_MACDFIXstream_MAMAstream_MAVPstream_MAXstream_MAXINDEXstream_MEDPRICEstream_MFIstream_MIDPOINTstream_MIDPRICEstream_MINstream_MININDEXstream_MINMAXstream_MINMAXINDEXstream_MINUS_DIstream_MINUS_DMstream_MOMstream_MULTstream_NATRstream_OBVstream_PLUS_DIstream_PLUS_DMstream_PPOstream_ROCstream_ROCPstream_ROCRstream_ROCR100stream_RSIstream_SARstream_SAREXTstream_SINstream_SINHstream_SMAstream_SQRTstream_STDDEVstream_STOCHstream_STOCHFstream_STOCHRSIstream_SUBstream_SUMstream_T3stream_TANstream_TANHstream_TEMAstream_TRANGEstream_TRIMAstream_TRIXstream_TSFstream_TYPPRICEstream_ULTOSCstream_VARstream_WCLPRICEstream_WILLRstream_WMAsys_ta_check_success_ta_func_unst_ids_ta_getFuncInfo_ta_getFuncTable_ta_getGroupTable_ta_getInputParameterInfo_ta_getOptInputParameterInfo_ta_getOutputParameterInfo_ta_get_compatibility_ta_get_unstable_period_ta_initialize_ta_restore_candle_default_settings_ta_set_candle_settings_ta_set_compatibility_ta_set_unstable_period_ta_shutdown__ta_version__tabletalib._ta_lib__test__threadingtimeStamptimeperiodtimeperiod1timeperiod2timeperiod3to_numpytype_type__unicode__updateupdate_infouppervaluevalue_rangevaluesversionvfactorvolumevolume_data\200\001\34001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330""\004\r\210T\220\026\220q\230\001\330\004\021\220\021\330\004\021\220\034\230R\230v\240X\250R\250t\2606\270\030\300\022\3004\300|\320S`\320`a\320am\320mn\320n}\320}~\320~\177\330\004\025\220Q\220o\240Q\330\004\013\2101\200\001\34001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\034\230R\230v\240X\250R\250t\2606\270\030\300\022\3004\300|\320S`\320`a\320am\320mn\320n}\320}~\320~\177\330\004\025\220Q\220o\240Q\330\004\013\2101\200\001\34001\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0337\260r\270\021\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\320\021$\240B\240d\250)\260;\270d\300&\310\001\310\031\320R_\320_`\320`l\320lm\320m|\360\000\000}\001H\002\360\000\000H\002O\002\360\000\000O\002U\002\360\000\000U\002V\002\360\000\000V\002W\002\330\004\025\220Q\320\026,\250A\330\004\013\2101\200\001\3400H\320Hb\320b|\320|}\3600\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\017\210q\330\004\017\210q\330\004\021\220\034\230R\230v\240X\250R\250t\2606\270\030\300\022\3004\300|\320S`\320`o\320o~\360\000\000\177\001N\002\360\000\000N\002O\002\360\000\000O\002[\002\360\000\000[\002\\\002\360\000\000\\\002k\002\360\000\000k\002l\002\360\000\000l\002w\002\360\000\000w\002x\002\360\000\000x\002y\002\330\004\025\220Q\220o\240Q\330\004\013\210;\220a\200\001\340/0\360.\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\024\220A\330\004\022\220!\330\004\021\220\033\230B\230f\240H\250B\250d\260&\270\010\300\002\300$\300l\320Ra\320ab\320bn\320no\320o~\320~\177\360\000\000@\002J\002\360\000\000J\002K\002\360\000\000K\002[\002\360\000\000[\002\\\002\360\000\000\\\002]\002\330\004\025\220Q\220n\240A\330\004\013\210:\320\025%\240Q\200\001\340/0""\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\033\230B\230f\240H\250B\250d\260&\270\010\300\002\300$\300l\320R_\320_`\320`l\320lm\320m|\320|}\320}~\330\004\025\220Q\220n\240A\330\004\013\2101\200\001\34012\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\035\230b\240\006\240h\250b\260\004\260F\270(\300\"\300D\310\014\320Ta\320ab\320bn\320no\320o~\320~\177\360\000\000@\002A\002\330\004\025\220Q\320\026&\240a\330\004\013\2101\200\001\340\004\017\320\017#\2401\330\004\013\2101\200\001\360\014\000\005\022\320\021+\2501\320,>\270a\320?O\310u\320TU\320UV\330\004\025\220Q\320\0263\2601\340\004\013\2109\220A\220T\230\021\330\004\013\2104\210q\220\003\2201\220H\230F\240!\340\004\007\200w\210c\220\025\220d\230%\230x\240x\250y\270\001\330\010\017\210t\2201\220C\220q\230\001\340\004\005\330\010\020\220\001\330\010\021\220\033\230A\230T\240\030\250\021\200\001\340#;\2701\360(\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\230?\250\"\250M\270\021\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\026\220r\230\024\230Y\240k\260\024\260V\2701\270I\300]\320R[\320[\\\320\\h\320hi\320ix\360\000\000y\001D\002\360\000\000D\002K\002\360\000\000K\002Q\002\360\000\000Q\002R\002\360\000\000R\002S\002\330\004\025\220Q\220i\230q\330\004\013\2101\200\001\340#;\2701\360(\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\230?\250\"\250M\270\021\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\026\220r\230\024\230Y\240k\260\024\260V\2701\270I\300]\320R\\\320\\]\320]i\320ij\320jy\360\000\000z\001E\002\360\000\000E\002L\002\360\000\000L\002R\002\360\000\000R\002S\002""\360\000\000S\002T\002\330\004\025\220Q\220i\230q\330\004\013\2101\200\001\340\004\022\320\0222\260!\2601\330\004\025\220Q\320\0269\270\021\200\001\360\014\000\005\022\220\037\240\001\320!3\2601\3204D\300A\300Q\330\004\025\220Q\320\026(\250\001\340\004\005\330\010\020\220\t\230\021\230$\230a\330\010\021\220\031\230!\2304\230q\330\010\030\230\t\240\021\240$\240a\330\010\032\230+\240Q\240d\250(\260!\330\010\026\220c\230\021\230$\230a\330\010\032\230#\230Q\230d\240!\330\010\027\220s\230!\2304\230q\200\001\34034\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\020\220\001\330\004\020\220\001\330\004\021\220\037\240\002\240&\250\010\260\002\260$\260f\270H\300B\300d\310,\320Vc\320cd\320dp\320pq\360\000\000r\001A\002\360\000\000A\002B\002\360\000\000B\002N\002\360\000\000N\002O\002\360\000\000O\002P\002\330\004\025\220Q\320\026(\250\001\330\004\013\210<\220q\200\001\34045\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033;\2702\270Q\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\320\021(\250\002\250$\250i\260{\300$\300f\310A\310Y\320Vc\320cd\320dp\320pq\360\000\000r\001A\002\360\000\000A\002L\002\360\000\000L\002S\002\360\000\000S\002Y\002\360\000\000Y\002Z\002\360\000\000Z\002[\002\330\004\025\220Q\320\0260\260\001\330\004\013\2101\200\001\360\014\000\005\023\320\022#\2405\250\001\330\004\007\200t\210:\220Q\220m\2401\330\010\026\220d\230!\2301\330\004\016\210c\220\021\220$\220d\230!\2303\230a\230~\250Q\330\004\016\210c\220\021\220$\220d\230!\2303\230a\230~\250Q\360\006\000\005\010\200u\210B\210b\220\003\2205\230\002\230!\2302\230Q\330\010\017\210q\360\n\000\005\013\210!\330\004\010\210\005\210V\2201\220I\230W\240A\240Q\330\010\013\2101\210B\210b\220\002\220!\330\014\017\210w\220a\320\027(\250\001\250\021\250\"\250A\330\004\013\2101\200\001\34078\360&\000\005\014\210;\220a""\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\320\021$\240B\240f\250H\260B\260d\270&\300\010\310\002\310$\310l\320Zg\320gh\320ht\320tu\360\000\000v\001E\002\360\000\000E\002F\002\360\000\000F\002G\002\330\004\025\220Q\320\026,\250A\330\004\013\2101\200A\3602\000\t\021\220\004\220A\330\010\013\210:\220Q\220n\240A\330\014\033\2301\330\014\020\220\007\220t\320\0336\260a\330\020\023\320\023&\240g\250Q\330\024\030\230\n\240!\240>\260\021\330\024\036\230d\240'\250\034\260Q\340\024\036\230d\240'\250\021\330\020\023\2201\330\024 \240\007\240q\250\001\330\014\017\210s\220!\220>\240\023\240A\330\020\025\320\025%\240Q\330\020\025\320\025&\240a\330\020\027\220q\340\020\026\220i\230q\240\001\330/6\260c\270\021\270.\310\002\310!\3309:\33004\260E\270\021\270!\330\010\017\210q\200\001\340)A\320A[\320[u\320uv\3600\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0330\260\002\260-\270\177\310o\320]^\330\004\017\320\017 \240\001\240\030\250\021\330\004\017\320\017 \240\001\240\030\250\021\330\004\021\220\034\230R\230t\2409\250K\260t\2706\300\021\300)\310=\320Xg\320gv\360\000\000w\001F\002\360\000\000F\002G\002\360\000\000G\002S\002\360\000\000S\002T\002\360\000\000T\002c\002\360\000\000c\002n\002\360\000\000n\002v\002\360\000\000v\002|\002\360\000\000|\002}\002\360\000\000}\002H\003\360\000\000H\003S\003\360\000\000S\003[\003\360\000\000[\003a\003\360\000\000a\003b\003\360\000\000b\003c\003\330\004\025\220Q\220o\240Q\330\004\013\210;\220a\200A\330\010\020\220\004\220A\330\010#\2401\330\010\014\210N\230%\230q\330\014\033\2305\240\014\250A\250[\270\001\270\021\330\014\017\210z\230\021\230.\250\001\330\020\024\220H\230A\330\024,\250G\2601\260A\340\020(\250\007\250q\260\001\330\010\017\210q\200A\360\016\000\t\021\220\004\220A\340\010\033\2302\230\\\250\025\250k\270\021\270+\300Q\300a\330\034 \240\016\250e""\260;\270e\3001\330\010#\2402\240S\250\005\250\\\270\021\270\"\270A\270Q\330$(\250\005\250U\260!\360\006\000\t\020\210t\2201\220A\330\010\027\220q\330\010#\2404\320'B\300!\330\010\013\2105\220\004\220D\230\n\240!\2404\240q\250\004\250A\330\014\020\220\003\2207\230)\2401\240A\330\020\023\2204\220z\240\021\240%\240q\330\024\025\340\020\021\330\024 \240\001\320!9\270\021\270&\300\001\330\027\030\330\024\032\320\032G\300q\330\030\033\2301\230A\330\030\034\230E\240\021\240!\330\024\032\230)\2401\240A\340\010\013\320\013\036\230g\240Q\330\020\024\220J\230a\230u\240O\2601\330\014'\240u\250M\270\021\330\r \240\007\240q\330\020\024\220J\230a\230u\240O\2601\330\014'\240u\250M\270\031\300!\340\014'\240t\2504\250q\260\005\260Q\340\010\013\2103\210a\210~\230S\240\003\2401\240A\330\014\020\320\020!\240\021\240!\330\014\023\2204\220q\230\003\2301\230A\330\r\020\220\001\220\036\230t\320#<\270A\330\020\024\220C\220q\230\006\230c\240\024\240Z\250q\260\004\260A\260T\270\021\330\014\022\320\022A\300\021\330\020\023\2201\220A\330\020\024\220E\230\021\230!\330\014\022\220)\2301\230A\340\010\014\320\014\036\230b\240\010\250\001\330\010\014\320\014\034\230A\360\006\000\t\r\210L\230\t\240\021\330\014\021\220\033\230A\230[\250\001\250\033\260A\330\010\r\210U\220!\320\023#\2404\240q\360\006\000\t\r\210L\230\t\240\021\330\014\021\220\034\230Q\230k\250\021\320*<\270A\330\014\021\220\025\220a\220~\240Q\240n\260A\340\010\017\210t\2201\200A\330\010\020\220\004\220A\330\010#\2404\320'B\300!\360\006\000\t\020\210q\330\010\014\320\014\034\230A\330\014\025\220U\230-\240q\250\001\330\014\017\320\017\037\230w\240e\2501\330\024\036\230a\230x\240q\330\020\031\230\026\230w\240g\250Q\250a\330\021!\240\027\250\005\250Q\330\024\036\230a\230x\240q\330\020\031\230\026\230y\250\002\250'\260\021\260!\330\014\020\220\007\220q\230\001\330\010\014\210M\230\025\230a\330\014\024\220D\320\030.\250a\250q\330\014\020\220\007\220q\230\001\360\006\000\t\023\220$\220l\240\"\240A\330\010\013\210:\220Q\220k\240\021\330\014""\023\2205\230\010\240\005\240Q\330\014\017\210t\220:\230Q\230f\240A\330\020\027\220t\2301\230A\330\014\021\220\030\230\021\230$\230a\230v\240Q\340\014\020\220\003\220:\230Y\240a\240u\250A\330\020\025\220X\230Q\230j\250\007\250q\260\001\330\010\r\320\r\036\230a\200A\360\016\000\t\021\220\004\220A\330\010\013\2104\210u\220A\330\014\020\320\020 \240\001\330\010\016\210e\2208\2307\240!\330\010\013\2104\210z\230\021\230%\230q\330\014\022\220$\220a\220q\330\010\013\320\013\036\230g\240U\250!\330\020\032\230!\2305\240\017\250q\330\014\024\220E\230\035\240a\330\014\017\210s\220!\2205\230\003\2301\330\020\027\220\177\240a\240s\250!\2504\250v\260Q\340\020\027\320\027)\250\021\250%\250}\270A\270Q\330*0\260\001\330*2\260$\260a\330\r \240\007\240u\250A\330\020\032\230!\2305\240\017\250q\330\014\017\210s\220!\2205\230\003\2301\330\020\027\220\177\240a\240s\250!\2501\340\020\027\320\027)\250\021\250%\250}\270A\270Q\330*1\260\024\260Q\340\014\023\2203\220a\220v\230S\240\001\240\025\240c\250\027\260\001\200A\340\010\020\220\004\220A\330\010\013\2104\210w\220a\220w\230a\330\014\021\220\030\230\021\330\014\021\320\021!\240\021\360\006\000\r\022\220\037\240\013\2501\330\014\021\220\036\230{\250!\330\014\021\220\033\230K\240q\330\014\021\320\021\"\240!\360\006\000\r\022\220\030\230\037\250\001\250\024\250Q\360\006\000\r\021\220\005\220V\2301\230E\240\025\240d\250!\2501\330\020\027\320\0270\260\001\260\024\260Y\270a\330\020\035\230T\240\021\240!\330\020\023\2204\220q\320\030(\250\003\2501\330\024\030\230\001\320\031+\320+H\310\001\310\021\330\020\025\220\\\240\021\240.\260\001\330\014\021\220\025\220a\320\027(\250\004\250A\360\006\000\r\021\220\005\220V\2301\230E\240\025\240d\250!\2501\330\020\027\320\0273\2601\260D\270\t\300\021\330\020\035\230T\240\021\240!\330\020\025\220[\240\001\240\036\250q\330\014\021\220\025\220a\320\027'\240t\2501\360\006\000\r\022\220\025\220a\320\027)\250\033\260A\330\014\020\220\005\220V\2301\230E\240\025\240d\250!\2501\330\020\027\320\0271\260\021\260$\260i""\270q\330\020\036\230d\240!\2401\330\020\025\220U\230!\230?\250!\250?\270$\270a\270q\330\020\025\220X\230Q\230o\250Q\330\014\021\220\025\220a\320\027)\250\024\250Q\330\010\017\210q\200A\330\010\014\210A\330\014\023\2206\230\021\330\014\023\2206\230\021\330\014\023\2206\230\021\330\014\023\2207\230!\330\014\023\2207\230!\330\014\023\2208\2301\330\014\023\2207\230!\330\014\023\2207\230!\330\014\023\2205\230\001\200A\360\010\000\t\021\220\004\220A\330\010\020\220\005\220[\240\001\240\033\250A\250Q\330\010\013\2106\220\023\220A\330\014\024\220E\230\033\240A\240[\260\001\260\021\330\010\017\210q\200A\360\010\000\t\021\220\004\220A\330\010\014\210L\320\030(\250\013\2606\270\021\330\014\021\220\034\230Q\230k\250\021\320*<\270A\330\014\021\220\025\220a\220~\240Q\240n\260A\330\010\r\320\r\036\230a\200A\360\010\000\t\021\220\004\220A\330\010\026\220a\340\010\014\210G\2201\330\014\017\210t\2203\220e\2301\330\020\030\230\006\230a\230q\330\020\023\2204\320\027/\250q\260\005\260Q\330\024\031\230\033\240A\240T\250\021\250+\260V\2701\270A\330\024\"\240!\330\021\025\220S\230\005\230Q\330\020\025\220\\\240\021\240$\240a\320'9\270\026\270q\300\001\330\020\025\220U\230!\230>\250\021\250'\260\026\260q\270\001\340\010\013\2101\330\014\031\230\021\330\014\017\210t\320\023$\240A\240T\250\021\250!\330\020\035\230Q\330\014\017\210s\220!\2206\230\022\2301\330\020\024\220C\220~\240Y\250a\250u\260A\330\024\031\230\021\330\024\027\220r\230\022\2303\230a\230q\330\030 \240\004\240A\240Q\330\030\033\2304\320\0377\260q\270\014\300A\330\034!\240\033\250A\250[\270\001\270\033\300A\330\034*\250!\340\010\013\2105\220\003\2201\330\014\017\210q\330\020\025\220U\230!\320\033+\2504\250q\330\014\021\320\021\"\240!\200A\360\014\000\t\021\220\004\220A\340\010\021\320\021&\240a\240t\2501\330\010\014\210C\210}\230I\240Q\240e\2501\330\014\024\220D\320\030.\250a\250q\330\014\024\220E\230\033\240A\240Z\250q\260\001\330\014\017\210v\220V\320\0332\260#\260V\2706\300\021\330\020)\250\021\250(\260#\260Q\330\021\027""\220v\320\0357\260s\270&\300\006\300a\330\020,\250A\250X\260S\270\001\340\010\023\320\023#\2401\240A\330\010\034\230A\230Q\330\010\017\210q\200A\360\010\000\t\021\220\004\220A\330\010\013\320\013\036\230g\240Q\330\014\020\220\n\230!\2305\240\017\250q\330\014\023\2205\230\r\240V\2501\340\014\023\2205\230\r\240U\250!\200A\360\010\000\t\021\220\004\220A\330\010\016\210k\230\021\330\010\014\210M\230\025\230a\330\014\017\210q\220\r\230T\320!7\260q\270\001\330\010\017\210q\200A\360\n\000\t\021\220\004\220A\330\010\016\210k\230\021\330\010\014\210N\230%\230q\330\014\017\210q\220\016\230e\240<\250q\260\013\2701\270A\330\010\017\210q\200\001\360\004\000A\002B\002\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0336\260b\270\001\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021#\2402\240T\250\031\260+\270T\300\026\300q\310\t\320Q\\\320\\`\320`f\320fg\320gp\320p{\320{~\360\000\000\177\001E\002\360\000\000E\002F\002\360\000\000F\002O\002\360\000\000O\002Z\002\360\000\000Z\002_\002\360\000\000_\002e\002\360\000\000e\002f\002\360\000\000f\002o\002\360\000\000o\002}\002\360\000\000}\002~\002\360\000\000~\002J\003\360\000\000J\003K\003\360\000\000K\003Z\003\360\000\000Z\003b\003\360\000\000b\003l\003\360\000\000l\003r\003\360\000\000r\003s\003\360\000\000s\003t\003\330\004\025\220Q\320\026+\2501\330\004\013\2101\200A\330\010\020\220\004\220H\230K\240q\250\013\2601\260A\330\010\013\2106\220\027\320\0305\260Q\330\014\024\220A\330\r\023\2207\320\0324\260A\330\014\024\220A\340\010\013\210:\220Q\220g\230Q\330\013\022\220!\330\r\023\2207\230!\330\014\022\220)\2301\330\020\021\330\024 \240\005\240[\260\004\260A\260V\2701\330\010\017\210q\200A\340\010\014\210J\220m\2406\250\021\330\010\014\210M\230\024\230Q""\330\010\014\210J\220i\230q\240\004\240A\360\006\000\t\r\210O\2309\240F\250!\360\006\000\t\r\320\014\036\230b\240\010\250\001\330\010\014\210O\2301\200A\330\010\017\320\017%\240Q\240d\250&\260\001\260\021\200\001\360\004\000A\002Y\002\360\000\000Y\002Z\002\360.\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210[\230\001\230\021\330\004\022\220)\2306\240\021\330\004\r\210]\230!\2306\240\025\240g\250Q\330\004\016\210a\330\004\021\220\031\230\"\230F\240(\250\"\250D\260\006\260h\270b\300\004\300L\320P[\320[h\320hv\360\000\000w\001D\002\360\000\000D\002Q\002\360\000\000Q\002R\002\360\000\000R\002^\002\360\000\000^\002_\002\360\000\000_\002n\002\360\000\000n\002o\002\360\000\000o\002p\002\330\004\025\220Q\220l\240!\330\004\013\2101\200\001\340@A\360&\000\005\014\210;\220a\220q\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3005\310\001\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2502\250Q\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260$\260f\270A\270Y\300k\320QV\320V\\\320\\]\320]f\320fs\320st\360\000\000u\001A\002\360\000\000A\002B\002\360\000\000B\002Q\002\360\000\000Q\002\\\002\360\000\000\\\002c\002\360\000\000c\002i\002\360\000\000i\002j\002\360\000\000j\002k\002\330\004\025\220Q\220j\240\001\330\004\013\2101\200\001\340@A\360*\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300a\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033-\250R\250q\330\004\023\320\023$\240A\240X\250Q\330\004\021\320\021\"\240!\2408\2501\330\004\021\220\031\230\"\230D\240\t\250\033\260D\270\006\270a\270y\310\013\320SV\320V\\\320\\]\320]f\320fs\320st\360\000\000u\001A\002\360\000\000A\002B\002\360\000\000B""\002Q\002\360\000\000Q\002\\\002\360\000\000\\\002h\002\360\000\000h\002n\002\360\000\000n\002o\002\360\000\000o\002z\002\360\000\000z\002E\003\360\000\000E\003O\003\360\000\000O\003U\003\360\000\000U\003V\003\360\000\000V\003W\003\330\004\025\220Q\220l\240!\330\004\013\210?\230!\200\001\340$<\270A\360(\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2502\250]\270!\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260$\260f\270A\270Y\300m\320S[\320[\\\320\\h\320hi\320ix\360\000\000y\001D\002\360\000\000D\002K\002\360\000\000K\002Q\002\360\000\000Q\002R\002\360\000\000R\002S\002\330\004\025\220Q\220j\240\001\330\004\013\2101\200A\360\n\000\t\017\210d\220(\230(\240%\240q\330\010\013\2104\210z\230\021\230%\230q\330\014\022\220$\220a\220q\330\010\017\210q\200A\330\010\017\210q\200A\330\010\017\210q\220\007\220q\230\001\200A\330\010\017\210t\2208\2301\230A\200A\360\n\000\t\020\210t\2208\2305\240\001\240\021\200A\360\n\000\t\020\210t\2208\2305\240\005\240Q\200A\360\n\000\t\020\210t\2208\2305\240\001\240\037\260\005\260Q\200A\330\010\017\210u\220A\220S\230\001\200A\330\010\017\210u\220B\220d\230!\200A\330\010\017\210w\220a\220t\2308\2401\200\001\340A[\320[z\360\000\000{\001_\002\360\000\000_\002\177\002\360\000\000\177\002b\003\360\000\000b\003G\004\360\000\000G\004h\004\360\000\000h\004i\004\3604\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300a\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033.\250b\260\r\320=O\320Of\320fy\360\000\000z\001P\002\360\000\000P\002h\002\360\000\000h\002|\002\360\000\000|\002}\002\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\032\2302\230T\240\031\250+\260T\270\026\270q\300\t\310\033\320TW\320W]\320]^\320^g\320gt\360\000\000u\001G\002\360""\000\000G\002^\002\360\000\000^\002q\002\360\000\000q\002G\003\360\000\000G\003_\003\360\000\000_\003s\003\360\000\000s\003J\004\360\000\000J\004K\004\360\000\000K\004W\004\360\000\000W\004X\004\360\000\000X\004g\004\360\000\000g\004r\004\360\000\000r\004y\004\360\000\000y\004\177\004\360\000\000\177\004@\005\360\000\000@\005A\005\330\004\025\220Q\220m\2401\330\004\013\2101\200\001\340BC\360(\000\005\r\210K\220q\230\001\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2307\240!\330\004\r\210]\230!\2308\240:\250U\260(\270*\300E\310\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033,\250B\250a\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\030\230\022\2304\230y\250\013\2605\270\006\270a\270y\310\013\320SX\320X^\320^_\320_h\320hu\320uv\360\000\000w\001C\002\360\000\000C\002D\002\360\000\000D\002S\002\360\000\000S\002^\002\360\000\000^\002e\002\360\000\000e\002k\002\360\000\000k\002l\002\360\000\000l\002m\002\330\004\025\220Q\220k\240\021\330\004\013\2101\200\001\340BC\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300a\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033/\250r\260\021\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\033\230B\230d\240)\250;\260d\270&\300\001\300\031\310+\320UX\320X^\320^_\320_h\320hu\320uv\360\000\000w\001C\002\360\000\000C\002D\002\360\000\000D\002S\002\360\000\000S\002^\002\360\000\000^\002e\002\360\000\000e\002k\002\360\000\000k\002l\002\360\000\000l\002m\002\330\004\025\220Q\220n\240A\330\004\013\2101\200\001\340*B\300!\360(\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\026\220r\230\026\230x\240r\250\024\250V\2608\2702\270T\300\034\310]\320Zc\320cd\320dp\320pq\360\000\000r\001A\002\360\000\000A\002B\002\360\000\000B\002C\002\330\004\025\220Q\220i\230q\330\004\013\2101\200\001\340*B""\300!\360(\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\026\220r\230\026\230x\240r\250\024\250V\2608\2702\270T\300\034\310]\320Zd\320de\320eq\320qr\360\000\000s\001B\002\360\000\000B\002C\002\360\000\000C\002D\002\330\004\025\220Q\220i\230q\330\004\013\2101\200\001\340+C\3001\360(\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310m\320[c\320cd\320dp\320pq\360\000\000r\001A\002\360\000\000A\002B\002\360\000\000B\002C\002\330\004\025\220Q\220j\240\001\330\004\013\2101\200\001\340+C\320C[\320[\\\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310m\320[h\320hq\320qr\320r~\320~\177\360\000\000@\002O\002\360\000\000O\002P\002\360\000\000P\002Q\002\330\004\025\220Q\220j\240\001\330\004\013\2101\200\001\340CD\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300a\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0330\260\002\260!\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\034\230R\230t\2409\250K\260t\2706\300\021\300)\310;\320VY\320Y_\320_`\320`i\320iv\320vw\360\000\000x\001D\002\360\000\000D\002E\002\360\000\000E\002T\002\360\000\000T\002_\002\360\000\000_\002f\002\360\000\000f\002l\002\360\000\000l\002m\002\360\000\000m\002n\002\330\004\025\220Q\220o\240Q\330\004\013\2101\200\001\340CZ\320Zq\320qr\360,\000\005\014\210;\220a\220q\330\004\016\210k\230\021\230!\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3007\310!\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033,\250B\250l\270,\300a\330\004\016\320\016\037\230q""\240\010\250\001\330\004\021\220\030\230\022\2304\230y\250\013\2604\260v\270Q\270i\300{\320RY\320Y_\320_`\320`i\320iu\360\000\000v\001B\002\360\000\000B\002K\002\360\000\000K\002L\002\360\000\000L\002X\002\360\000\000X\002Y\002\360\000\000Y\002h\002\360\000\000h\002s\002\360\000\000s\002z\002\360\000\000z\002@\003\360\000\000@\003A\003\360\000\000A\003B\003\330\004\025\220Q\220k\240\021\330\004\013\2101\200\001\360\004\000C\002D\002\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0338\270\002\270!\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021%\240R\240t\2509\260K\270t\3006\310\021\310)\320S^\320^b\320bh\320hi\320ir\320r}\360\000\000~\001A\002\360\000\000A\002G\002\360\000\000G\002H\002\360\000\000H\002Q\002\360\000\000Q\002\\\002\360\000\000\\\002a\002\360\000\000a\002g\002\360\000\000g\002h\002\360\000\000h\002q\002\360\000\000q\002\177\002\360\000\000\177\002@\003\360\000\000@\003L\003\360\000\000L\003M\003\360\000\000M\003\\\003\360\000\000\\\003d\003\360\000\000d\003n\003\360\000\000n\003t\003\360\000\000t\003u\003\360\000\000u\003v\003\330\004\025\220Q\320\026-\250Q\330\004\013\2101\200\001\340,D\320D\\\320\\]\3602\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\024\220A\330\004\022\220!\330\004\021\220\030\230\022\2306\240\030\250\022\2504\250v\260X\270R\270t\300<\310}\320\\i\320ix\320xy\360\000\000z\001F\002\360\000\000F\002G\002\360\000\000G\002V\002\360\000\000V\002W\002\360\000\000W\002a\002\360\000\000a\002b\002\360\000\000b\002r\002\360\000\000r\002s\002\360\000\000s\002t\002\330\004\025\220Q\220k\240\021\330\004\013\210:\320\025%\240Q\200\001\340DE\360(\000\005\r\210K\220q\230\001\330\004\014\210K""\220q\230\001\330\004\r\210]\230!\2307\240!\330\004\r\210]\230!\2308\240:\250U\260(\270*\300E\310\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033.\250b\260\001\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\032\2302\230T\240\031\250+\260U\270&\300\001\300\031\310+\320UZ\320Z`\320`a\320aj\320jw\320wx\360\000\000y\001E\002\360\000\000E\002F\002\360\000\000F\002U\002\360\000\000U\002`\002\360\000\000`\002g\002\360\000\000g\002m\002\360\000\000m\002n\002\360\000\000n\002o\002\330\004\025\220Q\220m\2401\330\004\013\2101\200\001\360\004\000D\002E\002\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\220\036\230r\240\026\240x\250r\260\024\260V\2708\3002\300T\310\034\320Ua\320al\320ly\360\000\000z\001H\002\360\000\000H\002I\002\360\000\000I\002U\002\360\000\000U\002V\002\360\000\000V\002e\002\360\000\000e\002f\002\360\000\000f\002g\002\330\004\025\220Q\320\026'\240q\330\004\013\2101\200\001\360\004\000D\002E\002\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0339\270\022\2701\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021&\240b\250\004\250I\260[\300\004\300F\310!\3109\320T_\320_c\320ci\320ij\320js\320s~\360\000\000\177\001B\002\360\000\000B\002H\002\360\000\000H\002I\002\360\000\000I\002R\002\360\000\000R\002]\002\360\000\000]\002b\002\360\000\000b\002h\002\360\000\000h\002i\002\360\000\000i\002r\002\360\000\000r\002@\003\360\000\000@\003A\003\360\000\000A\003M\003\360\000\000M\003N\003""\360\000\000N\003]\003\360\000\000]\003e\003\360\000\000e\003o\003\360\000\000o\003u\003\360\000\000u\003v\003\360\000\000v\003w\003\330\004\025\220Q\320\026.\250a\330\004\013\2101\200\001\340,E\300Q\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\016\210a\330\004\021\220\030\230\022\2306\240\030\250\022\2504\250v\260X\270R\270t\300<\310|\320[g\320gh\320ht\320tu\360\000\000v\001E\002\360\000\000E\002F\002\360\000\000F\002P\002\360\000\000P\002Q\002\360\000\000Q\002R\002\330\004\025\220Q\220k\240\021\330\004\013\210:\220Q\200\001\360\004\000E\002F\002\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033:\270\"\270A\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021'\240r\250\024\250Y\260k\300\024\300V\3101\310I\320U`\320`d\320dj\320jk\320kt\320t\177\360\000\000@\002C\002\360\000\000C\002I\002\360\000\000I\002J\002\360\000\000J\002S\002\360\000\000S\002^\002\360\000\000^\002c\002\360\000\000c\002i\002\360\000\000i\002j\002\360\000\000j\002s\002\360\000\000s\002A\003\360\000\000A\003B\003\360\000\000B\003N\003\360\000\000N\003O\003\360\000\000O\003^\003\360\000\000^\003f\003\360\000\000f\003p\003\360\000\000p\003v\003\360\000\000v\003w\003\360\000\000w\003x\003\330\004\025\220Q\320\026/\250q\330\004\013\2101\200\001\340E`\320`a\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\r\210]\230!\2306\240\021\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310k\320Yh\320hr\320rs\320s\177\360\000\000@\002A\002\360\000\000A\002P\002\360\000\000P\002Q\002\360\000\000Q\002R\002\330\004\025\220Q\220j\240""\001\330\004\013\2101\200\001\340.F\320F]\320]t\320tu\3604\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\027\220q\330\004\030\230\001\330\004\027\220q\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300\\\320Q^\320^h\320hr\320r{\320{|\360\000\000}\001I\002\360\000\000I\002J\002\360\000\000J\002Y\002\360\000\000Y\002Z\002\360\000\000Z\002m\002\360\000\000m\002n\002\360\000\000n\002B\003\360\000\000B\003C\003\360\000\000C\003D\003\330\004\025\220Q\220m\2401\330\004\013\320\013\036\320\0362\260!\200\001\340.F\300a\360(\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300\\\320Q^\320^f\320fg\320gs\320st\360\000\000u\001D\002\360\000\000D\002E\002\360\000\000E\002F\002\330\004\025\220Q\220m\2401\330\004\013\2101\200\001\340/G\320GZ\320Zr\360\000\000s\001F\002\360\000\000F\002`\002\360\000\000`\002a\002\3608\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\024\220A\330\004\022\220!\330\004\021\220\033\230B\230f\240H\250B\250d\260&\270\010\300\002\300$\300l\320R_\320_l\320ly\360\000\000z\001G\002\360\000\000G\002V\002\360\000\000V\002e\002\360\000\000e\002f\002\360\000\000f\002r\002\360\000\000r\002s\002\360\000\000s\002B\003\360\000\000B\003C\003\360\000\000C\003M\003\360\000\000M\003N\003\360\000\000N\003^\003\360\000\000^\003_\003\360\000\000_\003`\003\330\004\025\220Q\220n\240A\330\004\013\210:\320\025%\240Q\200\001\340GH\360(\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\021\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310m\320[h\320hi\320iu\320uv\360\000\000w\001F\002\360\000\000F\002G\002\360\000\000G\002H\002\330\004\025\220Q\220j\240\001""\330\004\013\2101\200\001\340GH\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\r\210]\230!\2306\240\021\330\004\023\2201\330\004\021\220\021\330\004\021\220\031\230\"\230F\240(\250\"\250D\260\006\260h\270b\300\004\300L\320P[\320[h\320hi\320iu\320uv\360\000\000w\001F\002\360\000\000F\002G\002\360\000\000G\002V\002\360\000\000V\002W\002\360\000\000W\002X\002\330\004\025\220Q\220l\240!\330\004\013\210?\230!\200\001\360\004\000H\002I\002\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021#\2402\240V\2508\2602\260T\270\026\270x\300r\310\024\310\\\320Ye\320ep\320p}\360\000\000~\001L\002\360\000\000L\002M\002\360\000\000M\002Y\002\360\000\000Y\002Z\002\360\000\000Z\002i\002\360\000\000i\002j\002\360\000\000j\002k\002\330\004\025\220Q\320\026+\2501\330\004\013\2101\200\001\340Hb\360\000\000c\001B\002\360\000\000B\002f\002\360\000\000f\002F\003\360\000\000F\003i\003\360\000\000i\003N\004\360\000\000N\004o\004\360\000\000o\004p\004\3606\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\r\210]\230!\2306\240\021\330\004\016\210a\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300\\\320Q\\\320\\i\320i{\360\000\000|\001S\002\360\000\000S\002f\002\360\000\000f\002|\002\360\000\000|\002T\003\360\000\000T\003h\003\360\000\000h\003\177\003\360\000\000\177\003@\004\360\000\000@\004L\004\360\000\000L\004M\004\360\000\000M\004\\\004\360\000\000\\\004]\004\360\000\000]\004^\004\330\004\025\220Q\220m\2401\330\004\013\2101\200\001\340IJ\360*\000\005\r\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q""\330\004\r\210]\230!\2307\240!\330\004\016\210a\330\004\021\220\030\230\022\2306\240\030\250\022\2504\250v\260X\270R\270t\300=\320P]\320]j\320jk\320kw\320wx\360\000\000y\001H\002\360\000\000H\002I\002\360\000\000I\002J\002\330\004\025\220Q\220k\240\021\330\004\013\2101\200\001\340IJ\360(\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\r\210]\230!\2306\240\021\330\004\016\210a\330\004\021\220\033\230B\230f\240H\250B\250d\260&\270\010\300\002\300$\300l\320R]\320]j\320jk\320kw\320wx\360\000\000y\001H\002\360\000\000H\002I\002\360\000\000I\002J\002\330\004\025\220Q\220n\240A\330\004\013\2101\200\001\340JK\360(\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\r\210]\230!\2306\240\021\330\004\016\210a\330\004\021\220\034\230R\230v\240X\250R\250t\2606\270\030\300\022\3004\300|\320S^\320^k\320kl\320lx\320xy\360\000\000z\001I\002\360\000\000I\002J\002\360\000\000J\002K\002\330\004\025\220Q\220o\240Q\330\004\013\2101\200\001\360\004\000J\002K\002\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021%\240R\240v\250X\260R\260t\2706\300\030\310\022\3104\310|\320[g\320gr\320r\177\360\000\000@\002N\002\360\000\000N\002O\002\360\000\000O\002[\002\360\000\000[\002\\\002\360\000\000\\\002k\002\360\000\000k\002l\002\360\000\000l\002m\002\330\004\025\220Q\320\026-\250Q\330\004\013\2101\200\001\340Ja\320ax\320xy\360.\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\016\210k\230\021\230!\330\004\023\2209\230G\2401\330\004\r\210]\230!\2306\240\021\330\004\016\210a\330\004\021\220\030\230\022\2306\240\030\250\022\2504\250v\260X\270R\270t\300<\310\177\320^j\320jv\320v""\177\360\000\000@\002A\002\360\000\000A\002M\002\360\000\000M\002N\002\360\000\000N\002]\002\360\000\000]\002^\002\360\000\000^\002_\002\330\004\025\220Q\220k\240\021\330\004\013\2101\200\001\340KL\360*\000\005\r\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2307\240!\330\004\016\210a\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300]\320R_\320_l\320lm\320my\320yz\360\000\000{\001J\002\360\000\000J\002K\002\360\000\000K\002L\002\330\004\025\220Q\220m\2401\330\004\013\2101\200\001\360\004\000K\002L\002\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021&\240b\250\006\250h\260b\270\004\270F\300(\310\"\310D\320P\\\320\\h\320hs\360\000\000t\001A\002\360\000\000A\002O\002\360\000\000O\002P\002\360\000\000P\002\\\002\360\000\000\\\002]\002\360\000\000]\002l\002\360\000\000l\002m\002\360\000\000m\002n\002\330\004\025\220Q\320\026.\250a\330\004\013\2101\200\001\360(\000\005\r\210K\220q\230\001\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2307\240!\330\004\r\210]\230!\2308\240:\250U\260(\270*\300E\310\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2501\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260%\260v\270Q\270i\300{\320RW\320W]\320]^\320^g\320gh\320ht\320tu\360\000\000v\001E\002\360\000\000E\002P\002\360\000\000P\002W\002\360\000\000W\002]\002\360\000\000]\002^\002\360\000\000^\002_\002\330\004\025\220Q\220j\240\001\330\004\013\2101\200\001\360(\000\005\r\210K\220q\230\001\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2307\240!\330\004\r\210]\230!\2308\240:\250U\260(\270*\300E\310\021\330\004\r\210U\220'\230\022\2307""\240\"\240A\330\004\017\210w\220e\320\033,\250A\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\030\230\022\2304\230y\250\013\2605\270\006\270a\270y\310\013\320SX\320X^\320^_\320_h\320hi\320iu\320uv\360\000\000w\001F\002\360\000\000F\002Q\002\360\000\000Q\002X\002\360\000\000X\002^\002\360\000\000^\002_\002\360\000\000_\002`\002\330\004\025\220Q\220k\240\021\330\004\013\2101\200\001\360*\000\005\r\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2307\240!\330\004\016\210a\330\004\021\220\030\230\022\2306\240\030\250\022\2504\250v\260X\270R\270t\300=\320P]\320]^\320^j\320jk\320kz\320z{\320{|\330\004\025\220Q\220k\240\021\330\004\013\2101\200\001\360*\000\005\r\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2307\240!\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300-\310}\320\\]\320]i\320ij\320jy\320yz\320z{\330\004\025\220Q\220j\240\001\330\004\013\2101\200\001\360\004\000L\002M\002\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021'\240r\250\026\250x\260r\270\024\270V\3008\3102\310T\320Q]\320]i\320it\360\000\000u\001B\002\360\000\000B\002P\002\360\000\000P\002Q\002\360\000\000Q\002]\002\360\000\000]\002^\002\360\000\000^\002m\002\360\000\000m\002n\002\360\000\000n\002o\002\330\004\025\220Q\320\026/\250q\330\004\013\2101\200N\220!\360\016\000\t\014\2101\330\014\020\320\020!\240\021\240!\330\010\014\320\014\034\230A\330\010\017\210t\2201\200\001\360\014\000\005\022\320\021-\250Q\320.@\300\001\320AQ\320QV\320VW\320WX\330\004\025\220Q\320\0265\260Q\340\004\013\2109\220A\220T\230\021\330\004""\013\2104\210q\220\003\2201\220J\230f\240A\330\004\024\220C\220q\230\004\320\034.\250d\260&\270\002\270'\300\024\300Q\340\004\005\330\010\020\220\001\330\010\030\230\t\240\021\240$\240a\330\010\020\220\004\220A\330\010\020\220\t\230\021\230$\230a\330\010\031\230\021\330\010\021\220\021\320\004\035\230Q\360\010\000\t\021\220\004\220A\330\010\025\220[\240\003\2401\330\010\022\220'\230\021\230!\330\010\014\210G\2209\230J\240f\250A\330\014\017\210t\320\023+\2501\250G\2601\330\020\025\220[\240\001\240\026\240q\250\013\2601\330\010\r\320\r\036\230a\330\010\r\210U\220!\320\023#\2404\240q\200\001\360\n\000\005\026\220Q\320\026/\320/B\300!\3001\300A\330\004\r\210Q\330\004\010\210\005\210V\2201\220E\230\021\330\010\016\210g\220Q\220f\230A\230U\240'\250\021\250!\330\004\025\220Q\320\026.\320.@\300\001\300\021\330\004\013\2101\200\001\360\014\000\005\022\320\021*\250!\320+=\270Q\320>N\310e\320ST\320TU\330\004\025\220Q\320\0262\260!\340\004\013\2109\220A\220T\230\021\330\004\013\2104\210q\220\003\2201\220G\2306\240\021\330\004\007\200w\210c\220\021\330\010\017\210t\2208\2301\230H\240A\330\t\021\220\023\220A\330\010\017\210q\340\004\005\330\010\020\220\001\330\010\030\230\013\2401\240D\250\010\260\001\200\001\360\n\000\005\026\220Q\320\026.\320.@\300\001\300\027\310\001\310\021\330\004\020\220\001\330\004\010\210\005\210V\2201\220E\230\021\330\010\021\220\027\230\001\230\026\230q\240\005\240W\250A\250Q\330\004\025\220Q\320\026-\320->\270a\270q\330\004\013\2101\200\001\340\004\022\220.\240\001\330\004\025\220Q\320\026'\240q\200\001\340\004\034\320\034-\250Q\250a\330\004\020\320\020%\240Q\240a\330\004\013\2101\200\001\340\004\034\320\034-\250Q\250a\330\004\022\320\022'\240q\250\004\250A\330\004\025\220Q\320\026.\250a\200\001\340(@\320@S\320Sk\320k~\360\000\000\177\001Y\002\360\000\000Y\002Z\002\3608\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033/\250r""\260\035\270m\310=\320Xe\320et\320tu\330\004\016\320\016\037\230q\240\010\250\001\330\004\024\320\024%\240Q\240h\250a\330\004\022\320\022#\2401\240H\250A\330\004\021\220\033\230B\230d\240)\250;\260d\270&\300\001\300\031\310-\320Wd\320dq\320q~\360\000\000\177\001N\002\360\000\000N\002]\002\360\000\000]\002^\002\360\000\000^\002j\002\360\000\000j\002k\002\360\000\000k\002z\002\360\000\000z\002E\003\360\000\000E\003L\003\360\000\000L\003R\003\360\000\000R\003S\003\360\000\000S\003^\003\360\000\000^\003i\003\360\000\000i\003v\003\360\000\000v\003|\003\360\000\000|\003}\003\360\000\000}\003H\004\360\000\000H\004S\004\360\000\000S\004^\004\360\000\000^\004d\004\360\000\000d\004e\004\360\000\000e\004f\004\330\004\025\220Q\220n\240A\330\004\013\210:\320\025%\240Q\200\001\340$<\320Y\320YZ\360(\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300a\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2502\250_\270A\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260$\260f\270A\270Y\300k\320QT\320TZ\320Z[\320[d\320ds\320s}\320}~\360\000\000\177\001K\002\360\000\000K\002L\002\360\000\000L\002[\002\360\000\000[\002f\002\360\000\000f\002m\002\360\000\000m\002s\002\360\000\000s\002t\002\360\000\000t\002u\002\330\004\025\220Q\220j\240\001\330\004\013\2101\200\001\340YZ\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r""\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\230?\250\"\250A\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\026\220r\230\024\230Y\240k\260\024\260V\2701\270I\300[\320PS\320SY\320YZ\320Zc\320cn\320ns\320sy\320yz\360\000\000{\001D\002\360\000\000D\002Q\002\360\000\000Q\002R\002\360\000\000R\002^\002\360\000\000^\002_\002\360\000\000_\002n\002\360\000\000n\002y\002\360\000\000y\002@\003\360\000\000@\003F\003\360\000\000F\003G\003\360\000\000G\003H\003\330\004\025\220Q\220i\230q\330\004\013\2101\200\001\340Z[\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2502\250Q\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260$\260f\270A\270Y\300k\320QT\320TZ\320Z[\320[d\320do\320ot\320tz\320z{\360\000\000|\001E\002\360\000\000E\002R\002\360\000\000R\002S\002\360\000\000S\002_\002\360\000\000_\002`\002\360\000\000`\002o\002\360\000\000o\002z\002\360\000\000z\002A\003\360\000\000A\003G\003\360\000\000G\003H\003\360\000\000H\003I\003\330\004\025\220Q\220j\240\001\330\004\013\2101\200\001\340\004\022\220,\230a\330\004\025\220Q\220o\240Q\200\001\340`a\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\016\210a\330\004\021\220\026\220r\230\026\230x\240r\250\024\250V\2608\2702\270T\300\034\310[\320Xe\320er\320rs\320s\177\360\000\000@\002A\002\360\000\000A\002P\002\360\000\000P\002Q\002\360\000\000Q\002R\002\330\004\025\220Q\220i\230q\330\004\013\2101\200\001\340%>\270a\360,\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330""\004\017\210w\220e\320\033,\250B\250l\270!\330\004\016\320\016\037\230q\240\010\250\001\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\030\230\022\2304\230y\250\013\2604\260v\270Q\270i\300|\320S_\320_`\320`l\320lm\320m|\360\000\000}\001H\002\360\000\000H\002O\002\360\000\000O\002U\002\360\000\000U\002V\002\360\000\000V\002a\002\360\000\000a\002l\002\360\000\000l\002s\002\360\000\000s\002y\002\360\000\000y\002z\002\360\000\000z\002{\002\330\004\025\220Q\220k\240\021\330\004\013\210:\220Q\200\001\340ab\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310k\320Yf\320fs\320st\360\000\000u\001A\002\360\000\000A\002B\002\360\000\000B\002Q\002\360\000\000Q\002R\002\360\000\000R\002S\002\330\004\025\220Q\220j\240\001\330\004\013\2101\200\001\360(\000\005\014\210;\220a\220q\330\004\r\210[\230\001\230\021\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3006\310\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2501\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260$\260f\270A\270Y\300k\320QW\320W]\320]^\320^g\320gh\320ht\320tu\360\000\000v\001E\002\360\000\000E\002P\002\360\000\000P\002W\002\360\000\000W\002]\002\360\000\000]\002^\002\360\000\000^\002_\002\330\004\025\220Q\220j\240\001\330\004\013\2101\200\001\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210[\230\001\230\021\330\004\022\220)\2306\240\021\330\004\r\210]\230!\2306\240\021\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310n\320\\]\320]i\320ij\320jy\320yz\320z{\330\004\025\220Q\220j\240\001\330\004\013\2101\200\001\340\004\022\320\022&\240a\240q\330\004\025\220Q""\320\026-\250Q\200\001\360(\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\r\210]\230!\2306\240\021\330\004\016\210a\330\004\021\220\034\230R\230v\240X\250R\250t\2606\270\030\300\022\3004\300|\320S^\320^_\320_k\320kl\320l{\320{|\320|}\330\004\025\220Q\220o\240Q\330\004\013\2101\200\001\340~\177\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210[\230\001\230\021\330\004\022\220)\2306\240\021\330\004\r\210]\230!\2306\240\025\240g\250Q\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310k\320Yf\320ft\360\000\000u\001B\002\360\000\000B\002C\002\360\000\000C\002O\002\360\000\000O\002P\002\360\000\000P\002_\002\360\000\000_\002`\002\360\000\000`\002a\002\330\004\025\220Q\220j\240\001\330\004\013\2101\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210[\230\001\230\021\330\004\022\220)\2306\240\021\330\004\r\210]\230!\2306\240\025\240g\250Q\330\004\016\210a\330\004\021\220\026\220r\230\026\230x\240r\250\024\250V\2608\2702\270T\300\034\310[\320Xe\320es\320st\360\000\000u\001A\002\360\000\000A\002B\002\360\000\000B\002Q\002\360\000\000Q\002R\002\360\000\000R\002S\002\330\004\025\220Q\220i\230q\330\004\013\2101\200\001\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\016\210a\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300\\\320Q\\\320\\i\320ij\320jv\320vw\360\000\000x\001G\002\360\000\000G\002H\002\360\000\000H\002I\002\330\004\025\220Q\220m\2401\330\004\013\2101\200\001""\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\016\210a\330\004\021\220\034\230R\230v\240X\250R\250t\2606\270\030\300\022\3004\300|\320S^\320^k\320kl\320lx\320xy\360\000\000z\001I\002\360\000\000I\002J\002\360\000\000J\002K\002\330\004\025\220Q\220o\240Q\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\021\220\021\330\004\021\320\021!\240\022\2406\250\030\260\022\2604\260v\270X\300R\300t\310<\320WX\320Xd\320de\320et\320tu\320uv\330\004\025\220Q\320\026)\250\021\330\004\013\2101\200\001\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\021\220\021\330\004\024\220A\330\004\021\220\035\230b\240\006\240h\250b\260\004\260F\270(\300\"\300D\310\014\320TU\320Ua\320ab\320bq\320qr\320r\177\360\000\000@\002A\002\360\000\000A\002B\002\330\004\025\220Q\320\026&\240a\330\004\013\210=\230\001\200\001\340./\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\r\210Q\330\004\r\210Q\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300\\\320Q^\320^_\320_k\320kl\320l{\320{|\360\000\000}\001F\002\360\000\000F\002G\002\360\000\000G\002H\002\330\004\025\220Q\220m\2401\330\004\013\2109\220A\200\001\340./\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300\\\320Q^\320^_\320_k\320kl\320l{\320{|\320|}\330\004\025\220Q\220m\2401\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\320\021!\240\022\2406\250\030\260\022\2604\260v\270X\300R\300t\310<\320WX\320Xd\320de\320et""\320tu\320uv\330\004\025\220Q\320\026)\250\021\330\004\013\2101\200\001\340,-\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\030\230\022\2306\240\030\250\022\2504\250v\260X\270R\270t\300<\310}\320\\]\320]i\320ij\320jy\320yz\320z{\330\004\025\220Q\220k\240\021\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\030\230\022\2306\240\030\250\022\2504\250v\260X\270R\270t\300<\310q\320P\\\320\\]\320]l\320lm\320mn\330\004\025\220Q\220k\240\021\330\004\013\2101\200\001\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\022\220!\330\004\021\220\033\230B\230f\240H\250B\250d\260&\270\010\300\002\300$\300l\320RS\320S_\320_`\320`o\320op\320pz\320z{\320{|\330\004\025\220Q\220n\240A\330\004\013\210:\220Q\200\001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\031\230\"\230F\240(\250\"\250D\260\006\260h\270b\300\004\300L\320PQ\320Q]\320]^\320^m\320mn\320no\330\004\025\220Q\220l\240!\330\004\013\2101\200\001\340-.\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\031\230\"\230F\240(\250\"\250D\260\006\260h\270b\300\004\300L\320P]\320]^\320^j\320jk\320kz\320z{\320{|\330\004\025\220Q\220l\240!\330\004\013\2101\200\001\340;<\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\320\021(\250\002\250&\260\010\270\002\270$\270f\300H\310B\310d\320R^\320^k\320kl\320lx\320xy\360\000\000z\001I\002\360\000\000I\002J\002\360\000\000J\002K\002\330\004\025\220Q\320\0260\260\001\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001""\330\004\016\210a\330\004\021\220\037\240\002\240&\250\010\260\002\260$\260f\270H\300B\300d\310,\320VW\320Wc\320cd\320ds\320st\320tu\330\004\025\220Q\320\026(\250\001\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310a\310|\320[\\\320\\k\320kl\320lm\330\004\025\220Q\220j\240\001\330\004\013\2101\200\001\340+,\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310m\320[\\\320\\h\320hi\320ix\320xy\320yz\330\004\025\220Q\220j\240\001\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\026\220r\230\026\230x\240r\250\024\250V\2608\2702\270T\300\034\310Q\310l\320Z[\320[j\320jk\320kl\330\004\025\220Q\220i\230q\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\036\230r\240\026\240x\250r\260\024\260V\2708\3002\300T\310\034\320UV\320Vb\320bc\320cr\320rs\320st\330\004\025\220Q\320\026'\240q\330\004\013\2101\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021#\2402\240V\2508\2602\260T\270\026\270x\300r\310\024\310\\\320Ye\320ep\320p}\320}~\360\000\000\177\001K\002\360\000\000K\002L\002\360\000\000L\002[\002\360\000\000[\002\\\002\360\000\000\\\002]\002\330\004\025\220Q\320\026+\2501\330\004\013\2101\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;""\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021!\240\022\2406\250\030\260\022\2604\260v\270X\300R\300t\310<\320Wc\320cn\320n{\320{|\360\000\000}\001I\002\360\000\000I\002J\002\360\000\000J\002Y\002\360\000\000Y\002Z\002\360\000\000Z\002[\002\330\004\025\220Q\320\026)\250\021\330\004\013\2101\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021$\240B\240f\250H\260B\260d\270&\300\010\310\002\310$\310l\320Zf\320fq\320q~\320~\177\360\000\000@\002L\002\360\000\000L\002M\002\360\000\000M\002\\\002\360\000\000\\\002]\002\360\000\000]\002^\002\330\004\025\220Q\320\026,\250A\330\004\013\2101\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\220\033\230B\230f\240H\250B\250d\260&\270\010\300\002\300$\300l\320R^\320^i\320iv\320vw\360\000\000x\001D\002\360\000\000D\002E\002\360\000\000E\002T\002\360\000\000T\002U\002\360\000\000U\002V\002\330\004\025\220Q\220n\240A\330\004\013\2101\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021\"\240\"\240F\250(\260\"\260D\270\006\270h\300b\310\004""\310L\320Xd\320do\320o|\320|}\360\000\000~\001J\002\360\000\000J\002K\002\360\000\000K\002Z\002\360\000\000Z\002[\002\360\000\000[\002\\\002\330\004\025\220Q\320\026*\250!\330\004\013\2101\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021%\240R\240v\250X\260R\260t\2706\300\030\310\022\3104\310|\320[g\320gr\320r\177\360\000\000@\002A\002\360\000\000A\002M\002\360\000\000M\002N\002\360\000\000N\002]\002\360\000\000]\002^\002\360\000\000^\002_\002\330\004\025\220Q\320\026-\250Q\330\004\013\2101\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\016\210a\330\004\021\220\034\230R\230v\240X\250R\250t\2606\270\030\300\022\3004\300|\320S_\320_j\320jw\320wx\360\000\000y\001E\002\360\000\000E\002F\002\360\000\000F\002U\002\360\000\000U\002V\002\360\000\000V\002W\002\330\004\025\220Q\220o\240Q\330\004\013\2101\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310l\320Ze\320er\320rs\320s\177\360\000\000@\002A\002\360\000\000A\002P\002\360\000\000P\002Q\002\360\000\000Q\002R\002\330\004\025\220Q\220j\240\001\330\004\013\2101\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t""\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\220\035\230b\240\006\240h\250b\260\004\260F\270(\300\"\300D\310\014\320T`\320`k\320kx\320xy\360\000\000z\001F\002\360\000\000F\002G\002\360\000\000G\002V\002\360\000\000V\002W\002\360\000\000W\002X\002\330\004\025\220Q\320\026&\240a\330\004\013\2101\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021&\240b\250\006\250h\260b\270\004\270F\300(\310\"\310D\320P\\\320\\h\320hs\360\000\000t\001A\002\360\000\000A\002B\002\360\000\000B\002N\002\360\000\000N\002O\002\360\000\000O\002^\002\360\000\000^\002_\002\360\000\000_\002`\002\330\004\025\220Q\320\026.\250a\330\004\013\2101\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\220\037\240\002\240&\250\010\260\002\260$\260f\270H\300B\300d\310,\320Vb\320bm\320mz\320z{\360\000\000|\001H\002\360\000\000H\002I\002\360\000\000I\002X\002\360\000\000X\002Y\002\360\000\000Y\002Z\002\330\004\025\220Q\320\026(\250\001\330\004\013\2101\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021(\250\002\250&\260\010\270\002\270$\270f\300H""\310B\310d\320R^\320^j\320ju\360\000\000v\001C\002\360\000\000C\002D\002\360\000\000D\002P\002\360\000\000P\002Q\002\360\000\000Q\002`\002\360\000\000`\002a\002\360\000\000a\002b\002\330\004\025\220Q\320\0260\260\001\330\004\013\2101\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\220\036\230r\240\026\240x\250r\260\024\260V\2708\3002\300T\310\034\320Ua\320al\320ly\320yz\360\000\000{\001G\002\360\000\000G\002H\002\360\000\000H\002W\002\360\000\000W\002X\002\360\000\000X\002Y\002\330\004\025\220Q\320\026'\240q\330\004\013\2101\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021'\240r\250\026\250x\260r\270\024\270V\3008\3102\310T\320Q]\320]i\320it\360\000\000u\001B\002\360\000\000B\002C\002\360\000\000C\002O\002\360\000\000O\002P\002\360\000\000P\002_\002\360\000\000_\002`\002\360\000\000`\002a\002\330\004\025\220Q\320\026/\250q\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300a\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0330\260\001\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\034\230R\230t\2409\250K\260t\2706\300\021\300)\310;\320VY\320Y_\320_`\320`i\320ij\320jv\320vw\360\000\000x\001G\002\360\000\000G\002R\002\360\000\000R\002Y\002\360\000\000Y\002_\002\360\000\000_\002`\002\360\000\000`\002a\002\330\004\025\220Q\220o\240Q\330\004\013\2101\200\001\340_`\360.\000""\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0330\260\002\260!\330\004\027\320\027(\250\001\250\030\260\021\330\004\030\320\030)\250\021\250(\260!\330\004\027\320\027(\250\001\250\030\260\021\330\004\021\220\034\230R\230t\2409\250K\260t\2706\300\021\300)\310;\320VY\320Y_\320_`\320`i\320it\320ty\320y\177\360\000\000@\002A\002\360\000\000A\002J\002\360\000\000J\002W\002\360\000\000W\002X\002\360\000\000X\002d\002\360\000\000d\002e\002\360\000\000e\002t\002\360\000\000t\002\177\002\360\000\000\177\002O\003\360\000\000O\003U\003\360\000\000U\003V\003\360\000\000V\003a\003\360\000\000a\003l\003\360\000\000l\003}\003\360\000\000}\003C\004\360\000\000C\004D\004\360\000\000D\004O\004\360\000\000O\004Z\004\360\000\000Z\004j\004\360\000\000j\004p\004\360\000\000p\004q\004\360\000\000q\004r\004\330\004\025\220Q\220o\240Q\330\004\013\320\013\036\320\0362\260!\200\001\340_`\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0330\260\002\260!\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\034\230R\230t\2409\250K\260t\2706\300\021\300)\310;\320VY\320Y_\320_`\320`i\320it\320ty\320y\177\360\000\000@\002A\002\360\000\000A\002J\002\360\000\000J\002W\002\360\000\000W\002X\002\360\000\000X\002d\002\360\000\000d\002e\002\360\000\000e\002t\002\360\000\000t\002\177\002\360\000\000\177\002F\003\360\000\000F\003L\003\360\000\000L\003M\003\360\000\000M\003N\003\330\004\025\220Q\220o\240Q\330\004\013\2101\200\001\340^_\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330""\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033/\250r\260\021\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\033\230B\230d\240)\250;\260d\270&\300\001\300\031\310+\320UX\320X^\320^_\320_h\320hs\320sx\320x~\320~\177\360\000\000@\002I\002\360\000\000I\002V\002\360\000\000V\002W\002\360\000\000W\002c\002\360\000\000c\002d\002\360\000\000d\002s\002\360\000\000s\002~\002\360\000\000~\002E\003\360\000\000E\003K\003\360\000\000K\003L\003\360\000\000L\003M\003\330\004\025\220Q\220n\240A\330\004\013\2101\200\001\340[\\\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033,\250B\250a\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\030\230\022\2304\230y\250\013\2604\260v\270Q\270i\300{\320RU\320U[\320[\\\320\\e\320ep\320pu\320u{\320{|\360\000\000}\001F\002\360\000\000F\002S\002\360\000\000S\002T\002\360\000\000T\002`\002\360\000\000`\002a\002\360\000\000a\002p\002\360\000\000p\002{\002\360\000\000{\002B\003\360\000\000B\003H\003\360\000\000H\003I\003\360\000\000I\003J\003\330\004\025\220Q\220k\240\021\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033.\250a\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\032\2302\230T\240\031\250+\260T\270\026\270q\300\t\310\033\320TW\320W]\320]^\320^g\320gr\320rw\320w}\320}~\360\000\000\177\001H\002\360\000\000H\002I\002\360\000\000I\002U\002\360\000\000U\002V\002\360\000\000V\002e\002\360\000\000e\002p\002\360\000\000p\002w\002\360\000""\000w\002}\002\360\000\000}\002~\002\360\000\000~\002\177\002\330\004\025\220Q\220m\2401\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0330\260\001\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\034\230R\230t\2409\250K\260t\2706\300\021\300)\310;\320VY\320Y_\320_`\320`i\320it\320ty\320y\177\360\000\000@\002A\002\360\000\000A\002J\002\360\000\000J\002K\002\360\000\000K\002W\002\360\000\000W\002X\002\360\000\000X\002g\002\360\000\000g\002r\002\360\000\000r\002y\002\360\000\000y\002\177\002\360\000\000\177\002@\003\360\000\000@\003A\003\330\004\025\220Q\220o\240Q\330\004\013\2101\200\001\340\\]\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033-\250R\250q\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\031\230\"\230D\240\t\250\033\260D\270\006\270a\270y\310\013\320SV\320V\\\320\\]\320]f\320fq\320qv\320v|\320|}\360\000\000~\001G\002\360\000\000G\002T\002\360\000\000T\002U\002\360\000\000U\002a\002\360\000\000a\002b\002\360\000\000b\002q\002\360\000\000q\002|\002\360\000\000|\002C\003\360\000\000C\003I\003\360\000\000I\003J\003\360\000\000J\003K\003\330\004\025\220Q\220l\240!\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210[\230\001\230\021\330\004\r\210]\230!\2306\240\025\240g\250Q\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]e\320eo\320ou\320uv\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\230?\250!\330\004\016\320\016\037\230q\240\010\250\001\330""\004\021\220\026\220r\230\024\230Y\240k\260\024\260V\2701\270I\300[\320PS\320SY\320YZ\320Zc\320cn\320ns\320sy\320yz\360\000\000{\001D\002\360\000\000D\002O\002\360\000\000O\002U\002\360\000\000U\002[\002\360\000\000[\002\\\002\360\000\000\\\002e\002\360\000\000e\002f\002\360\000\000f\002r\002\360\000\000r\002s\002\360\000\000s\002B\003\360\000\000B\003M\003\360\000\000M\003T\003\360\000\000T\003Z\003\360\000\000Z\003[\003\360\000\000[\003\\\003\330\004\025\220Q\220i\230q\330\004\013\2101\200\001\340)*\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0330\260\002\260!\330\004\021\220\036\230q\240\010\250\001\330\004\021\220\034\230R\230t\2409\250K\260t\2706\300\021\300)\310=\320XY\320Ye\320ef\320fu\320u}\360\000\000~\001H\002\360\000\000H\002N\002\360\000\000N\002O\002\360\000\000O\002P\002\330\004\025\220Q\220o\240Q\330\004\026\220f\230J\240a\330\004\010\210\007\320\017\037\230q\330\010\027\220q\230\006\230a\330\004\013\2101\200\001\340)*\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0330\260\002\260!\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\034\230R\230t\2409\250K\260t\2706\300\021\300)\310=\320XY\320Ye\320ef\320fu\360\000\000v\001A\002\360\000\000A\002H\002\360\000\000H\002N\002\360\000\000N\002O\002\360\000\000O\002P\002\330\004\025\220Q\220o\240Q\330\004\013\2101\200\001\340*+\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0331\260\022\2601\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\035\230b\240\004\240I\250[\270\004\270F\300!\3009\310M\320YZ\320Zf\320fg\320gv\360\000\000w\001B\002\360\000\000B\002I\002\360\000\000I\002O\002\360""\000\000O\002P\002\360\000\000P\002Q\002\330\004\025\220Q\320\026&\240a\330\004\013\2101\200\001\360*\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0331\260\021\330\004\021\320\021\"\240!\2408\2501\330\004\024\320\024%\240Q\240h\250a\330\004\021\220\035\230b\240\004\240I\250[\270\004\270F\300!\3009\310A\310\\\320YZ\320Zi\320it\320t~\360\000\000\177\001E\002\360\000\000E\002F\002\360\000\000F\002Q\002\360\000\000Q\002\\\002\360\000\000\\\002i\002\360\000\000i\002o\002\360\000\000o\002p\002\360\000\000p\002q\002\330\004\025\220Q\320\026&\240a\330\004\013\210=\230\001\200\001\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2501\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260$\260f\270A\270Y\300a\300|\320ST\320Tc\320cn\320nu\320u{\320{|\320|}\330\004\025\220Q\220j\240\001\330\004\013\2101\200\001\340$%\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2502\250Q\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260$\260f\270A\270Y\300m\320ST\320T`\320`a\320ap\320p{\360\000\000|\001C\002\360\000\000C\002I\002\360\000\000I\002J\002\360\000\000J\002K\002\330\004\025\220Q\220j\240\001\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0332\260!\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\036\230r\240\024\240Y\250k\270\024\270V\3001\300I\310Q\310l\320Z[\320[j\320ju\320u|\360\000\000}\001C\002\360\000\000C\002D\002\360\000\000D""\002E\002\330\004\025\220Q\320\026'\240q\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0333\2601\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\037\240\002\240$\240i\250{\270$\270f\300A\300Y\310a\310|\320[\\\320\\k\320kv\320v}\360\000\000~\001D\002\360\000\000D\002E\002\360\000\000E\002F\002\330\004\025\220Q\320\026(\250\001\330\004\013\2101\200\001\340,-\360*\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0333\2602\260Q\330\004\020\220\016\230a\230x\240q\330\004\020\220\016\230a\230x\240q\330\004\021\220\037\240\002\240$\240i\250{\270$\270f\300A\300Y\310m\320[\\\320\\h\320hi\320ix\360\000\000y\001A\002\360\000\000A\002J\002\360\000\000J\002P\002\360\000\000P\002Q\002\360\000\000Q\002\\\002\360\000\000\\\002d\002\360\000\000d\002m\002\360\000\000m\002s\002\360\000\000s\002t\002\360\000\000t\002u\002\330\004\025\220Q\320\026(\250\001\330\004\025\220V\2309\240A\330\004\010\210\007\320\017\037\230q\330\010\026\220a\220v\230Q\330\004\025\220V\2309\240A\330\004\010\210\007\320\017\037\230q\330\010\026\220a\220v\230Q\330\004\013\210<\220q\200\001\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0334\260A\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\320\021!\240\022\2404\240y\260\013\2704\270v\300Q\300i\310q\320P\\\320\\]\320]l\320lw\320w~\360\000\000\177\001E\002\360\000\000E\002F\002\360\000\000F\002G\002\330\004\025\220Q\320\026)\250\021\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w""\220e\320\0334\260A\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021!\240\022\2404\240y\260\013\2704\270v\300Q\300i\310q\320P\\\320\\]\320]l\320lt\320t~\360\000\000\177\001E\002\360\000\000E\002F\002\360\000\000F\002G\002\330\004\025\220Q\320\026)\250\021\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033,\250A\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\030\230\022\2304\230y\250\013\2604\260v\270Q\270i\300q\310\014\320TU\320Ud\320do\320ov\320v|\320|}\320}~\330\004\025\220Q\220k\240\021\330\004\013\2101\200\001\340%&\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033,\250B\250a\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\030\230\022\2304\230y\250\013\2604\260v\270Q\270i\300}\320TU\320Ua\320ab\320bq\320q|\360\000\000}\001D\002\360\000\000D\002J\002\360\000\000J\002K\002\360\000\000K\002L\002\330\004\025\220Q\220k\240\021\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033-\250Q\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\031\230\"\230D\240\t\250\033\260D\270\006\270a\270y\310\001\310\034\320UV\320Ve\320ep\320pw\320w}\320}~\320~\177\330\004\025\220Q\220l\240!\330\004\013\2101\200\001\340&'\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033-\250R\250q\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\031\230\"\230D\240\t\250\033\260D\270\006\270a\270y\310\r\320UV\320Vb\320bc\320cr\320r}\360\000\000~\001E\002\360\000\000E""\002K\002\360\000\000K\002L\002\360\000\000L\002M\002\330\004\025\220Q\220l\240!\330\004\013\2101\200\001\340'(\360*\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033.\250b\260\001\330\004\r\320\r\036\230a\230x\240q\330\004\r\320\r\036\230a\230x\240q\330\004\021\220\032\2302\230T\240\031\250+\260T\270\026\270q\300\t\310\035\320VW\320Wc\320cd\320ds\320s~\360\000\000\177\001E\002\360\000\000E\002K\002\360\000\000K\002L\002\360\000\000L\002W\002\360\000\000W\002b\002\360\000\000b\002h\002\360\000\000h\002n\002\360\000\000n\002o\002\360\000\000o\002p\002\330\004\025\220Q\220m\2401\330\004\013\2109\220A\200\001\340'(\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033.\250b\260\001\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\032\2302\230T\240\031\250+\260T\270\026\270q\300\t\310\035\320VW\320Wc\320cd\320ds\320s~\360\000\000\177\001F\002\360\000\000F\002L\002\360\000\000L\002M\002\360\000\000M\002N\002\330\004\025\220Q\220m\2401\330\004\013\2101\200\001\360*\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033/\250q\330\004\016\320\016\037\230q\240\010\250\001\330\004\022\320\022#\2401\240H\250A\330\004\021\220\033\230B\230d\240)\250;\260d\270&\300\001\300\031\310!\310<\320WX\320Xg\320gr\320ry\320y\177\360\000\000@\002A\002\360\000\000A\002L\002\360\000\000L\002W\002\360\000\000W\002b\002\360\000\000b\002h\002\360\000\000h\002i\002\360\000\000i\002j\002\330\004\025\220Q\220n\240A\330\004\013\210:\220Q\200\001\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004""\017\210w\220e\230?\250!\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\026\220r\230\024\230Y\240k\260\024\260V\2701\270I\300Q\300l\320RS\320Sb\320bm\320mt\320tz\320z{\320{|\330\004\025\220Q\220i\230q\330\004\013\2101\200\001\340()\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033/\250r\260\021\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\033\230B\230d\240)\250;\260d\270&\300\001\300\031\310-\320WX\320Xd\320de\320et\320t\177\360\000\000@\002G\002\360\000\000G\002M\002\360\000\000M\002N\002\360\000\000N\002O\002\330\004\025\220Q\220n\240A\330\004\013\2101\200\001\340()\360.\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033/\250r\260\021\330\004\016\320\016\037\230q\240\010\250\001\330\004\024\320\024%\240Q\240h\250a\330\004\022\320\022#\2401\240H\250A\330\004\021\220\033\230B\230d\240)\250;\260d\270&\300\001\300\031\310/\320YZ\320Zf\320fg\320gv\360\000\000w\001B\002\360\000\000B\002I\002\360\000\000I\002O\002\360\000\000O\002P\002\360\000\000P\002[\002\360\000\000[\002f\002\360\000\000f\002s\002\360\000\000s\002y\002\360\000\000y\002z\002\360\000\000z\002E\003\360\000\000E\003P\003\360\000\000P\003[\003\360\000\000[\003a\003\360\000\000a\003b\003\360\000\000b\003c\003\330\004\025\220Q\220n\240A\330\004\013\210:\320\025%\240Q\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0330\260\001\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\034\230R\230t\2409\250K\260t\2706\300\021\300)\310;""\320VZ\320Z`\320`a\320aj\320ju\320ux\320x~\320~\177\360\000\000@\002I\002\360\000\000I\002T\002\360\000\000T\002Y\002\360\000\000Y\002_\002\360\000\000_\002`\002\360\000\000`\002i\002\360\000\000i\002j\002\360\000\000j\002v\002\360\000\000v\002w\002\360\000\000w\002F\003\360\000\000F\003Q\003\360\000\000Q\003X\003\360\000\000X\003^\003\360\000\000^\003_\003\360\000\000_\003`\003\330\004\025\220Q\220o\240Q\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0334\260A\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021!\240\022\2404\240y\260\013\2704\270v\300Q\300i\310{\320Z^\320^d\320de\320en\320ny\320y|\360\000\000}\001C\002\360\000\000C\002D\002\360\000\000D\002M\002\360\000\000M\002X\002\360\000\000X\002]\002\360\000\000]\002c\002\360\000\000c\002d\002\360\000\000d\002m\002\360\000\000m\002n\002\360\000\000n\002z\002\360\000\000z\002{\002\360\000\000{\002J\003\360\000\000J\003R\003\360\000\000R\003\\\003\360\000\000\\\003b\003\360\000\000b\003c\003\360\000\000c\003d\003\330\004\025\220Q\320\026)\250\021\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033:\270!\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021'\240r\250\024\250Y\260k\300\024\300V\3101\310I\320U`\320`d\320dj\320jk\320kt\320t\177\360\000\000@\002C\002\360\000\000C\002I\002\360\000\000I\002J\002\360\000\000J\002S\002\360\000\000S\002^\002\360\000\000^\002c\002\360\000\000c\002i\002\360\000""\000i\002j\002\360\000\000j\002s\002\360\000\000s\002t\002\360\000\000t\002@\003\360\000\000@\003A\003\360\000\000A\003P\003\360\000\000P\003X\003\360\000\000X\003b\003\360\000\000b\003h\003\360\000\000h\003i\003\360\000\000i\003j\003\330\004\025\220Q\320\026/\250q\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033;\2701\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021(\250\002\250$\250i\260{\300$\300f\310A\310Y\320Va\320ae\320ek\320kl\320lu\360\000\000v\001A\002\360\000\000A\002D\002\360\000\000D\002J\002\360\000\000J\002K\002\360\000\000K\002T\002\360\000\000T\002_\002\360\000\000_\002d\002\360\000\000d\002j\002\360\000\000j\002k\002\360\000\000k\002t\002\360\000\000t\002u\002\360\000\000u\002A\003\360\000\000A\003B\003\360\000\000B\003Q\003\360\000\000Q\003Y\003\360\000\000Y\003c\003\360\000\000c\003i\003\360\000\000i\003j\003\360\000\000j\003k\003\330\004\025\220Q\320\0260\260\001\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033/\250q\330\004\021\220\036\230q\240\010\250\001\330\004\021\220\033\230B\230d\240)\250;\260d\270&\300\001\300\031\310+\320UY\320Y_\320_`\320`i\320it\320tw\320w}\320}~\360\000\000\177\001H\002\360\000\000H\002S\002\360\000\000S\002X\002\360\000\000X\002^\002\360\000\000^\002_\002\360\000\000_\002h\002\360\000\000h\002i\002\360\000\000i\002u\002\360\000\000u\002v\002\360\000\000v\002E\003\360\000\000E\003M\003\360\000\000M\003W\003""\360\000\000W\003]\003\360\000\000]\003^\003\360\000\000^\003_\003\330\004\025\220Q\220n\240A\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0335\260Q\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021\"\240\"\240D\250\t\260\033\270D\300\006\300a\300y\320P[\320[_\320_e\320ef\320fo\320oz\320z}\360\000\000~\001D\002\360\000\000D\002E\002\360\000\000E\002N\002\360\000\000N\002Y\002\360\000\000Y\002^\002\360\000\000^\002d\002\360\000\000d\002e\002\360\000\000e\002n\002\360\000\000n\002o\002\360\000\000o\002{\002\360\000\000{\002|\002\360\000\000|\002K\003\360\000\000K\003S\003\360\000\000S\003]\003\360\000\000]\003c\003\360\000\000c\003d\003\360\000\000d\003e\003\330\004\025\220Q\320\026*\250!\330\004\013\2101\200\001\340|}\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0332\260\"\260A\330\004\021\220\036\230q\240\010\250\001\330\004\021\220\036\230r\240\024\240Y\250k\270\024\270V\3001\300I\310[\320X\\\320\\b\320bc\320cl\320lw\320wz\360\000\000{\001A\002\360\000\000A\002B\002\360\000\000B\002K\002\360\000\000K\002V\002\360\000\000V\002[\002\360\000\000[\002a\002\360\000\000a\002b\002\360\000\000b\002k\002\360\000\000k\002y\002\360\000\000y\002z\002\360\000\000z\002F\003\360\000\000F\003G\003\360\000\000G\003V\003\360\000\000V\003^\003\360\000\000^\003h\003\360\000\000h\003n\003\360\000\000n\003o\003\360\000\000o\003p\003\330\004\025\220Q\320\026'\240q\330\004\013\2101\200\001\360&\000\005""\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2501\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260$\260f\270A\270Y\300k\320QU\320U[\320[\\\320\\e\320ep\320ps\320sy\320yz\360\000\000{\001D\002\360\000\000D\002O\002\360\000\000O\002T\002\360\000\000T\002Z\002\360\000\000Z\002[\002\360\000\000[\002d\002\360\000\000d\002e\002\360\000\000e\002q\002\360\000\000q\002r\002\360\000\000r\002A\003\360\000\000A\003L\003\360\000\000L\003S\003\360\000\000S\003Y\003\360\000\000Y\003Z\003\360\000\000Z\003[\003\330\004\025\220Q\220j\240\001\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0331\260\021\330\004\021\220\036\230q\240\010\250\001\330\004\021\220\035\230b\240\004\240I\250[\270\004\270F\300!\3009\310K\320W[\320[a\320ab\320bk\320kv\320vy\320y\177\360\000\000@\002A\002\360\000\000A\002J\002\360\000\000J\002U\002\360\000\000U\002Z\002\360\000\000Z\002`\002\360\000\000`\002a\002\360\000\000a\002j\002\360\000\000j\002k\002\360\000\000k\002w\002\360\000\000w\002x\002\360\000\000x\002G\003\360\000\000G\003O\003\360\000\000O\003Y\003\360\000\000Y\003_\003\360\000\000_\003`\003\360\000\000`\003a\003\330\004\025\220Q\320\026&\240a\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z""\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0336\260a\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021#\2402\240T\250\031\260+\270T\300\026\300q\310\t\320Q\\\320\\`\320`f\320fg\320gp\320p{\320{~\360\000\000\177\001E\002\360\000\000E\002F\002\360\000\000F\002O\002\360\000\000O\002Z\002\360\000\000Z\002_\002\360\000\000_\002e\002\360\000\000e\002f\002\360\000\000f\002o\002\360\000\000o\002p\002\360\000\000p\002|\002\360\000\000|\002}\002\360\000\000}\002L\003\360\000\000L\003T\003\360\000\000T\003^\003\360\000\000^\003d\003\360\000\000d\003e\003\360\000\000e\003f\003\330\004\025\220Q\320\026+\2501\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0332\260!\330\004\021\220\036\230q\240\010\250\001\330\004\021\220\036\230r\240\024\240Y\250k\270\024\270V\3001\300I\310[\320X\\\320\\b\320bc\320cl\320lw\320wz\360\000\000{\001A\002\360\000\000A\002B\002\360\000\000B\002K\002\360\000\000K\002V\002\360\000\000V\002[\002\360\000\000[\002a\002\360\000\000a\002b\002\360\000\000b\002k\002\360\000\000k\002l\002\360\000\000l\002x\002\360\000\000x\002y\002\360\000\000y\002H\003\360\000\000H\003P\003\360\000\000P\003Z\003\360\000\000Z\003`\003\360\000\000`\003a\003\360\000\000a\003b\003\330\004\025\220Q\320\026'\240q\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0333\2601\330\004\021\220\036\230q\240\010\250\001\330\004""\021\220\037\240\002\240$\240i\250{\270$\270f\300A\300Y\310k\320Y]\320]c\320cd\320dm\320mx\320x{\360\000\000|\001B\002\360\000\000B\002C\002\360\000\000C\002L\002\360\000\000L\002W\002\360\000\000W\002\\\002\360\000\000\\\002b\002\360\000\000b\002c\002\360\000\000c\002l\002\360\000\000l\002m\002\360\000\000m\002y\002\360\000\000y\002z\002\360\000\000z\002I\003\360\000\000I\003Q\003\360\000\000Q\003[\003\360\000\000[\003a\003\360\000\000a\003b\003\360\000\000b\003c\003\330\004\025\220Q\320\026(\250\001\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0338\270\001\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021%\240R\240t\2509\260K\270t\3006\310\021\310)\320S^\320^b\320bh\320hi\320ir\320r}\360\000\000~\001A\002\360\000\000A\002G\002\360\000\000G\002H\002\360\000\000H\002Q\002\360\000\000Q\002\\\002\360\000\000\\\002a\002\360\000\000a\002g\002\360\000\000g\002h\002\360\000\000h\002q\002\360\000\000q\002r\002\360\000\000r\002~\002\360\000\000~\002\177\002\360\000\000\177\002N\003\360\000\000N\003V\003\360\000\000V\003`\003\360\000\000`\003f\003\360\000\000f\003g\003\360\000\000g\003h\003\330\004\025\220Q\320\026-\250Q\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0339\270\021\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021&\240b\250\004\250I\260[\300\004\300F\310!\3109\320T_\320_c\320ci\320ij\320js\320s~\360\000\000\177\001B\002\360\000\000B\002H\002""\360\000\000H\002I\002\360\000\000I\002R\002\360\000\000R\002]\002\360\000\000]\002b\002\360\000\000b\002h\002\360\000\000h\002i\002\360\000\000i\002r\002\360\000\000r\002s\002\360\000\000s\002\177\002\360\000\000\177\002@\003\360\000\000@\003O\003\360\000\000O\003W\003\360\000\000W\003a\003\360\000\000a\003g\003\360\000\000g\003h\003\360\000\000h\003i\003\330\004\025\220Q\320\026.\250a\330\004\013\2101\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0337\260q\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021$\240B\240d\250)\260;\270d\300&\310\001\310\031\320R]\320]a\320ag\320gh\320hq\320q|\320|\177\360\000\000@\002F\002\360\000\000F\002G\002\360\000\000G\002P\002\360\000\000P\002[\002\360\000\000[\002`\002\360\000\000`\002f\002\360\000\000f\002g\002\360\000\000g\002p\002\360\000\000p\002q\002\360\000\000q\002}\002\360\000\000}\002~\002\360\000\000~\002M\003\360\000\000M\003U\003\360\000\000U\003_\003\360\000\000_\003e\003\360\000\000e\003f\003\360\000\000f\003g\003\330\004\025\220Q\320\026,\250A\330\004\013\2101\200\001\340bc\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\016\210a\330\004\021\220\030\230\022\2306\240\030\250\022\2504\250v\260X\270R\270t\300<\310{\320Zg\320gt\320tu\360\000\000v\001B\002\360\000\000B\002C\002\360\000\000C\002R\002\360\000\000R\002S\002\360\000\000S\002T\002\330\004\025\220Q\220k\240\021\330\004\013\2101\200\001\340c}\360\000\000~\001X\002\360\000\000X\002m\002\360\000\000m\002G\003\360\000\000G\003H\003\3606\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330""\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\017\210q\330\004\017\210q\330\004\021\220\031\230\"\230F\240(\250\"\250D\260\006\260h\270b\300\004\300L\320P[\320[h\320hw\360\000\000x\001G\002\360\000\000G\002V\002\360\000\000V\002e\002\360\000\000e\002t\002\360\000\000t\002u\002\360\000\000u\002A\003\360\000\000A\003B\003\360\000\000B\003Q\003\360\000\000Q\003R\003\360\000\000R\003]\003\360\000\000]\003^\003\360\000\000^\003_\003\330\004\025\220Q\220l\240!\330\004\013\210;\220a\200\001\340cd\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\016\210a\330\004\021\220\031\230\"\230F\240(\250\"\250D\260\006\260h\270b\300\004\300L\320P[\320[h\320hu\320uv\360\000\000w\001C\002\360\000\000C\002D\002\360\000\000D\002S\002\360\000\000S\002T\002\360\000\000T\002U\002\330\004\025\220Q\220l\240!\330\004\013\2101\200\001\340d}\360\000\000~\001W\002\360\000\000W\002X\002\360.\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\016\210a\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300\\\320Q\\\320\\i\320iw\360\000\000x\001F\002\360\000\000F\002T\002\360\000\000T\002U\002\360\000\000U\002a\002\360\000\000a\002b\002\360\000\000b\002q\002\360\000\000q\002r\002\360\000\000r\002s\002\330\004\025\220Q\220m\2401\330\004\013\2101\200\001\340d~\360\000\000\177\001Y\002\360\000\000Y\002Z\002\3602\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\017\210q""\330\004\017\210q\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300\\\320Q\\\320\\i\320ix\360\000\000y\001H\002\360\000\000H\002W\002\360\000\000W\002X\002\360\000\000X\002d\002\360\000\000d\002e\002\360\000\000e\002t\002\360\000\000t\002u\002\360\000\000u\002@\003\360\000\000@\003A\003\360\000\000A\003B\003\330\004\025\220Q\220m\2401\330\004\013\210;\220a\200\001\340ef\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\016\210a\330\004\021\220\033\230B\230f\240H\250B\250d\260&\270\010\300\002\300$\300l\320R]\320]j\320jw\320wx\360\000\000y\001E\002\360\000\000E\002F\002\360\000\000F\002U\002\360\000\000U\002V\002\360\000\000V\002W\002\330\004\025\220Q\220n\240A\330\004\013\2101\200\001\340fg\3602\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\027\220q\330\004\030\230\001\330\004\027\220q\330\004\021\220\034\230R\230v\240X\250R\250t\2606\270\030\300\022\3004\300|\320S^\320^k\320kx\320xy\360\000\000z\001F\002\360\000\000F\002G\002\360\000\000G\002V\002\360\000\000V\002W\002\360\000\000W\002j\002\360\000\000j\002k\002\360\000\000k\002\177\002\360\000\000\177\002@\003\360\000\000@\003A\003\330\004\025\220Q\220o\240Q\330\004\013\320\013\036\320\0362\260!\200\001\340fg\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\016\210a\330\004\021\220\034\230R\230v\240X\250R\250t\2606\270\030\300\022\3004\300|\320S^\320^k\320kx\320xy\360\000\000z\001F\002\360\000\000F\002G\002\360\000\000G\002V\002\360\000\000V\002W\002\360\000\000W\002X\002\330""\004\025\220Q\220o\240Q\330\004\013\2101\200\001\340\004\022\320\022'\240q\250\r\260[\300\013\3101\330\004\025\220Q\320\026.\250a\200\001\360\014\000\005\020\210q\330\004\020\220\001\220\031\230!\2309\240A\330\004\020\220\001\220\021\330\004\013\2101\330\004\010\210\007\210q\320\0201\260\022\2601\340\004\022\220)\2301\230A\330\004\010\210\007\210q\220\001\330\004\010\210\016\220a\330\010\020\220\013\2301\230A\330\010\013\2104\210z\230\021\230'\240\021\330\014\024\220A\330\010\014\210G\2201\320\024$\240L\260\001\340\004\r\210Y\220a\220q\330\004\007\200q\330\010\014\210G\2201\220A\330\004\010\210\t\220\021\330\010\014\210G\2201\320\024$\240G\2506\260\021\260!\330\010\021\220\027\230\001\230\035\240g\250V\2601\260A\330\010\020\220\001\220\031\230&\240\001\240\021\330\010\013\2106\220\023\220A\330\014\020\220\002\220%\220s\230%\230q\240\001\240\024\240R\240t\2507\260\"\260G\2701\270F\300!\3001\340\004\016\210i\220q\230\001\330\004\010\210\007\210q\220\001\330\004\010\210\n\220!\330\010\013\2107\220#\220Q\330\014\025\220Q\330\010\014\210G\2201\220I\230R\230q\340\004\r\210W\220A\220T\230\025\230a\230q\330\004\r\210W\220A\220Q\330\004\010\210\007\210q\220\003\2202\220U\230!\2301\330\004\024\220D\230\005\230Q\230a\330\004\013\210:\220Q\200\001\340'?\270q\360(\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033.\250b\260\r\270Q\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\032\2302\230T\240\031\250+\260T\270\026\270q\300\t\310\035\320V^\320^_\320_k\320kl\320l{\360\000\000|\001G\002\360\000\000G\002N\002\360\000\000N\002T\002\360\000\000T\002U\002\360\000\000U\002V\002\330\004\025\220Q\220m\2401\330\004\013\2101\200\001\340]v\360\000\000w\001P\002\360\000\000P\002Q\002\360*\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030""\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033.\250b\260\016\270n\310A\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\032\2302\230T\240\031\250+\260T\270\026\270q\300\t\310\033\320TW\320W]\320]^\320^g\320gr\320rw\320w}\320}~\360\000\000\177\001H\002\360\000\000H\002V\002\360\000\000V\002d\002\360\000\000d\002r\002\360\000\000r\002s\002\360\000\000s\002\177\002\360\000\000\177\002@\003\360\000\000@\003O\003\360\000\000O\003Z\003\360\000\000Z\003a\003\360\000\000a\003g\003\360\000\000g\003h\003\360\000\000h\003i\003\330\004\025\220Q\220m\2401\330\004\013\2101\200\001\340\\v\360\000\000w\001Q\002\360\000\000Q\002f\002\360\000\000f\002@\003\360\000\000@\003A\003\3602\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033-\250R\250\177\270o\310_\320\\k\320kl\330\004\017\320\017 \240\001\240\030\250\021\330\004\017\320\017 \240\001\240\030\250\021\330\004\021\220\031\230\"\230D\240\t\250\033\260D\270\006\270a\270y\310\013\320SV\320V\\\320\\]\320]f\320fq\320qv\320v|\320|}\360\000\000~\001G\002\360\000\000G\002V\002\360\000\000V\002e\002\360\000\000e\002t\002\360\000\000t\002C\003\360\000\000C\003R\003\360\000\000R\003S\003\360\000\000S\003_\003\360\000\000_\003`\003\360\000\000`\003o\003\360\000\000o\003z\003\360\000\000z\003B\004\360\000\000B\004H\004\360\000\000H\004I\004\360\000\000I\004T\004\360\000\000T\004_\004\360\000\000_\004g\004\360\000\000g\004m\004\360\000\000m\004n\004\360\000\000n\004o\004\330\004\025\220Q\220l\240!\330\004\013\210;\220a\200\001\340]w\360\000\000x\001R\002\360\000\000R\002S\002\360.\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032""\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033.\250b\260\017\270\177\310a\330\004\017\320\017 \240\001\240\030\250\021\330\004\017\320\017 \240\001\240\030\250\021\330\004\021\220\032\2302\230T\240\031\250+\260T\270\026\270q\300\t\310\033\320TW\320W]\320]^\320^g\320gr\320rw\320w}\320}~\360\000\000\177\001H\002\360\000\000H\002W\002\360\000\000W\002f\002\360\000\000f\002u\002\360\000\000u\002v\002\360\000\000v\002B\003\360\000\000B\003C\003\360\000\000C\003R\003\360\000\000R\003]\003\360\000\000]\003e\003\360\000\000e\003k\003\360\000\000k\003l\003\360\000\000l\003w\003\360\000\000w\003B\004\360\000\000B\004J\004\360\000\000J\004P\004\360\000\000P\004Q\004\360\000\000Q\004R\004\330\004\025\220Q\220m\2401\330\004\013\210;\220a\200\001\340wx\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210[\230\001\230\021\330\004\r\210]\230!\2306\240\025\240g\250Q\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]e\320eo\320ou\320uv\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2502\250Q\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260$\260f\270A\270Y\300k\320QT\320TZ\320Z[\320[d\320do\320ot\320tz\320z{\360\000\000|\001E\002\360\000\000E\002P\002\360\000\000P\002V\002\360\000\000V\002\\\002\360\000\000\\\002]\002\360\000\000]\002f\002\360\000\000f\002s\002\360\000\000s\002t\002\360\000\000t\002@\003\360\000\000@\003A\003\360\000\000A\003P\003\360\000\000P\003[\003\360\000\000[\003b\003\360\000\000b\003h\003\360\000\000h\003i\003\360\000\000i\003j\003\330\004\025\220Q\220j\240\001\330\004\013\2101\200\001\330\004\007\200y\220\003\2201\330\010\017\210q\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#""\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\340\010\026\220a\330\004\n\210)\2201\220A\330\010\027\220z\240\021\200\001\360\004\000z\001R\002\360\000\000R\002S\002\360(\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210[\230\001\230\021\330\004\r\210]\230!\2306\240\025\240g\250Q\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]e\320eo\320ou\320uv\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033-\250R\250}\270A\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\031\230\"\230D\240\t\250\033\260D\270\006\270a\270y\310\013\320SV\320V\\\320\\]\320]f\320fq\320qv\320v|\320|}\360\000\000~\001G\002\360\000\000G\002R\002\360\000\000R\002X\002\360\000\000X\002^\002\360\000\000^\002_\002\360\000\000_\002h\002\360\000\000h\002u\002\360\000\000u\002B\003\360\000\000B\003C\003\360\000\000C\003O\003\360\000\000O\003P\003\360\000\000P\003_\003\360\000\000_\003j\003\360\000\000j\003q\003\360\000\000q\003w\003\360\000\000w\003x\003\360\000\000x\003y\003\330\004\025\220Q\220l\240!\330\004\013\2101"; + PyObject *data = NULL; + CYTHON_UNUSED_VAR(__Pyx_DecompressString); + #endif + PyObject **stringtab = __pyx_mstate->__pyx_string_tab; + Py_ssize_t pos = 0; + for (int i = 0; i < 948; i++) { + Py_ssize_t bytes_length = index[i].length; + PyObject *string = PyUnicode_DecodeUTF8(bytes + pos, bytes_length, NULL); + if (likely(string) && i >= 97) PyUnicode_InternInPlace(&string); + if (unlikely(!string)) { + Py_XDECREF(data); + __PYX_ERR(0, 1, __pyx_L1_error) + } + stringtab[i] = string; + pos += bytes_length; + } + for (int i = 948; i < 1154; i++) { + Py_ssize_t bytes_length = index[i].length; + PyObject *string = PyBytes_FromStringAndSize(bytes + pos, bytes_length); + stringtab[i] = string; + pos += bytes_length; + if (unlikely(!string)) { + Py_XDECREF(data); + __PYX_ERR(0, 1, __pyx_L1_error) + } + } + Py_XDECREF(data); + for (Py_ssize_t i = 0; i < 1154; i++) { + if (unlikely(PyObject_Hash(stringtab[i]) == -1)) { + __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #if CYTHON_IMMORTAL_CONSTANTS + { + PyObject **table = stringtab + 948; + for (Py_ssize_t i=0; i<206; ++i) { + #if PY_VERSION_HEX >= 0x030F0000 + PyUnstable_SetImmortal(table[i]); + #elif CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + if ((PY_SSIZE_T_MAX <= _Py_IMMORTAL_REFCNT_LOCAL)) break; + #if PY_VERSION_HEX < 0x030E0000 + if (_Py_IsOwnedByCurrentThread(table[i]) && Py_REFCNT(table[i]) == 1) + #else + if (PyUnstable_Object_IsUniquelyReferenced(table[i])) + #endif + { + Py_SET_REFCNT(table[i], ((Py_ssize_t)_Py_IMMORTAL_REFCNT_LOCAL + 1)); + } + #else + if ((PY_SSIZE_T_MAX < _Py_IMMORTAL_INITIAL_REFCNT)) break; + Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT); + #endif + } + } + #endif + } + { + PyObject **numbertab = __pyx_mstate->__pyx_number_tab + 0; + int8_t const cint_constants_1[] = {0,-1,1,2,3,4,8,9,12,16,32,64}; + int16_t const cint_constants_2[] = {128,256,512,1024,2048,4096}; + int32_t const cint_constants_4[] = {16777216L,67108864L,134217728L,268435456L}; + for (int i = 0; i < 22; i++) { + numbertab[i] = PyLong_FromLong((i < 12 ? cint_constants_1[i - 0] : (i < 18 ? cint_constants_2[i - 12] : cint_constants_4[i - 18]))); + if (unlikely(!numbertab[i])) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #if CYTHON_IMMORTAL_CONSTANTS + { + PyObject **table = __pyx_mstate->__pyx_number_tab; + for (Py_ssize_t i=0; i<22; ++i) { + #if PY_VERSION_HEX >= 0x030F0000 + PyUnstable_SetImmortal(table[i]); + #elif CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + if ((PY_SSIZE_T_MAX <= _Py_IMMORTAL_REFCNT_LOCAL)) break; + #if PY_VERSION_HEX < 0x030E0000 + if (_Py_IsOwnedByCurrentThread(table[i]) && Py_REFCNT(table[i]) == 1) + #else + if (PyUnstable_Object_IsUniquelyReferenced(table[i])) + #endif + { + Py_SET_REFCNT(table[i], ((Py_ssize_t)_Py_IMMORTAL_REFCNT_LOCAL + 1)); + } + #else + if ((PY_SSIZE_T_MAX < _Py_IMMORTAL_INITIAL_REFCNT)) break; + Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT); + #endif + } + } + #endif return 0; __pyx_L1_error:; return -1; } /* #### Code section: init_codeobjects ### */ -\ - typedef struct { - unsigned int argcount : 4; - unsigned int num_posonly_args : 1; - unsigned int num_kwonly_args : 1; - unsigned int nlocals : 5; - unsigned int flags : 10; - unsigned int first_line : 13; - unsigned int line_table_length : 14; - } __Pyx_PyCode_New_function_description; +typedef struct { + unsigned int argcount : 4; + unsigned int num_posonly_args : 1; + unsigned int num_kwonly_args : 1; + unsigned int nlocals : 5; + unsigned int flags : 10; + unsigned int first_line : 13; +} __Pyx_PyCode_New_function_description; /* NewCodeObj.proto */ static PyObject* __Pyx_PyCode_New( const __Pyx_PyCode_New_function_description descr, PyObject * const *varnames, PyObject *filename, PyObject *funcname, - const char *line_table, + PyObject *line_table, PyObject *tuple_dedup_map ); @@ -88018,1849 +87160,1849 @@ static int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate) { PyObject* tuple_dedup_map = PyDict_New(); if (unlikely(!tuple_dedup_map)) return -1; { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 6, 253}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 6}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_function_name, __pyx_mstate->__pyx_n_u_ret_code}; - __pyx_mstate_global->__pyx_codeobj_tab[0] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_check_success, __pyx_k_y_1_q_Q_a_Q_a_Q_a_Q_a_Q_a_Q_a_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[0])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[0] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_check_success, __pyx_mstate->__pyx_kp_b_iso88591_y_1_q_Q_a_Q_a_Q_a_Q_a_Q_a_Q_a_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[0])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 50, 19}; + const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 50}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_ret_code}; - __pyx_mstate_global->__pyx_codeobj_tab[1] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_initialize, __pyx_k_Q_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[1])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[1] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_initialize, __pyx_mstate->__pyx_kp_b_iso88591_Q_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[1])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 55, 18}; + const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 55}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_ret_code}; - __pyx_mstate_global->__pyx_codeobj_tab[2] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_shutdown, __pyx_k_a_QoQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[2])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[2] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_shutdown, __pyx_mstate->__pyx_kp_b_iso88591_a_QoQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[2])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 63, 70}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 63}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; - __pyx_mstate_global->__pyx_codeobj_tab[3] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_init, __pyx_k_A_A_6_6_6_7_7_81_7_7_5, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[3])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[3] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_init, __pyx_mstate->__pyx_kp_b_iso88591_A_A_6_6_6_7_7_81_7_7_5, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[3])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 76, 13}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 76}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_type}; - __pyx_mstate_global->__pyx_codeobj_tab[4] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_getitem, __pyx_k_A_t81A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[4])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[4] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_getitem, __pyx_mstate->__pyx_kp_b_iso88591_A_t81A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[4])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 90, 34}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 90}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_name, __pyx_mstate->__pyx_n_u_period, __pyx_mstate->__pyx_n_u_ret_code, __pyx_mstate->__pyx_n_u_id}; - __pyx_mstate_global->__pyx_codeobj_tab[5] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_set_unstable_period, __pyx_k_Qa_q_A_Q_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[5])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[5] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_set_unstable_period, __pyx_mstate->__pyx_kp_b_iso88591_Qa_q_A_Q_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[5])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 96, 27}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 96}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_name, __pyx_mstate->__pyx_n_u_period, __pyx_mstate->__pyx_n_u_id}; - __pyx_mstate_global->__pyx_codeobj_tab[6] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_get_unstable_period, __pyx_k_Qa_Qa_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[6])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[6] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_get_unstable_period, __pyx_mstate->__pyx_kp_b_iso88591_Qa_Qa_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[6])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 102, 22}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 102}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_value, __pyx_mstate->__pyx_n_u_ret_code}; - __pyx_mstate_global->__pyx_codeobj_tab[7] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_set_compatibility, __pyx_k_aq_Q_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[7])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[7] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_set_compatibility, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[7])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 107, 15}; + const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 107}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_value}; - __pyx_mstate_global->__pyx_codeobj_tab[8] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_get_compatibility, __pyx_k_1_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[8])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[8] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_get_compatibility, __pyx_mstate->__pyx_kp_b_iso88591_1_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[8])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 124, 28}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 124}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_settingtype, __pyx_mstate->__pyx_n_u_rangetype, __pyx_mstate->__pyx_n_u_avgperiod, __pyx_mstate->__pyx_n_u_factor, __pyx_mstate->__pyx_n_u_ret_code}; - __pyx_mstate_global->__pyx_codeobj_tab[9] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_set_candle_settings, __pyx_k_q_1_Q_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[9])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[9] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_set_candle_settings, __pyx_mstate->__pyx_kp_b_iso88591_q_1_Q_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[9])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 129, 22}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 129}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_settingtype, __pyx_mstate->__pyx_n_u_ret_code}; - __pyx_mstate_global->__pyx_codeobj_tab[10] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_restore_candle_default_setti, __pyx_k_2_1_Q_9, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[10])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[10] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_restore_candle_default_setti, __pyx_mstate->__pyx_kp_b_iso88591_2_1_Q_9, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[10])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 142, 359}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 142}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outrealupperband, __pyx_mstate->__pyx_n_u_outrealmiddleband, __pyx_mstate->__pyx_n_u_outreallowerband}; - __pyx_mstate_global->__pyx_codeobj_tab[11] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ACCBANDS, __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[11])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[11] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ACCBANDS, __pyx_mstate->__pyx_kp_b_iso88591_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[11])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 181, 138}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 181}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[12] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ACOS, __pyx_k_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[12])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[12] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ACOS, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[12])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 210, 297}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 210}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_volume, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[13] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_AD, __pyx_k_aq_Qa_Kq_6_gQ_8_T_3hjX_eeoouuv, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[13])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[13] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_AD, __pyx_mstate->__pyx_kp_b_iso88591_aq_Qa_Kq_6_gQ_8_T_3hjX_eeoouuv, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[13])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 242, 193}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 242}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[14] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ADD, __pyx_k_Kq_Kq_7_8_U_E_U_7_A_we_1_q_i_vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[14])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[14] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ADD, __pyx_mstate->__pyx_kp_b_iso88591_Kq_Kq_7_8_U_E_U_7_A_we_1_q_i_vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[14])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {6, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 273, 330}; + const __Pyx_PyCode_New_function_description descr = {6, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 273}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_volume, __pyx_mstate->__pyx_n_u_fastperiod, __pyx_mstate->__pyx_n_u_slowperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[15] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ADOSC, __pyx_k_z_R_R_S_aq_Qa_Kq_6_gQ_8_T_3hjX, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[15])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[15] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ADOSC, __pyx_mstate->__pyx_kp_b_iso88591_z_R_R_S_aq_Qa_Kq_6_gQ_8_T_3hjX, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[15])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 308, 255}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 308}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[16] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ADX, __pyx_k_Z_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[16])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[16] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ADX, __pyx_mstate->__pyx_kp_b_iso88591_Z_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[16])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 341, 255}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 341}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[17] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ADXR, __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[17])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[17] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ADXR, __pyx_mstate->__pyx_kp_b_iso88591_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[17])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 374, 187}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 374}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_fastperiod, __pyx_mstate->__pyx_n_u_slowperiod, __pyx_mstate->__pyx_n_u_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[18] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_APO, __pyx_k_TTU_aq_T_q_8_T_U_7_A_we_2_q_q_i, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[18])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[18] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_APO, __pyx_mstate->__pyx_kp_b_iso88591_TTU_aq_T_q_8_T_U_7_A_we_2_q_q_i, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[18])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 407, 258}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 407}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outaroondown, __pyx_mstate->__pyx_n_u_outaroonup}; - __pyx_mstate_global->__pyx_codeobj_tab[19] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_AROON, __pyx_k_A_aq_Qa_6_8_T_3a_U_7_A_we_Rq_AX, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[19])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[19] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_AROON, __pyx_mstate->__pyx_kp_b_iso88591_A_aq_Qa_6_8_T_3a_U_7_A_we_Rq_AX, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[19])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 442, 209}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 442}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[20] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_AROONOSC, __pyx_k_CD_aq_Qa_6_8_T_3a_U_7_A_we_0_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[20])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[20] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_AROONOSC, __pyx_mstate->__pyx_kp_b_iso88591_CD_aq_Qa_6_8_T_3a_U_7_A_we_0_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[20])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 474, 138}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 474}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[21] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ASIN, __pyx_k_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[21])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[21] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ASIN, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[21])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 503, 138}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 503}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[22] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ATAN, __pyx_k_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[22])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[22] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ATAN, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[22])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 532, 255}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 532}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[23] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ATR, __pyx_k_Z_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[23])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[23] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ATR, __pyx_mstate->__pyx_kp_b_iso88591_Z_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[23])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 565, 298}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 565}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[24] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_AVGPRICE, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[24])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[24] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_AVGPRICE, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[24])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 597, 163}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 597}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[25] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_AVGDEV, __pyx_k_aq_T_q_8_T_U_7_A_we_b_q_2T_T_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[25])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[25] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_AVGDEV, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_b_q_2T_T_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[25])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 15, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 628, 304}; + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 15, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 628}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_nbdevup, __pyx_mstate->__pyx_n_u_nbdevdn, __pyx_mstate->__pyx_n_u_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outrealupperband, __pyx_mstate->__pyx_n_u_outrealmiddleband, __pyx_mstate->__pyx_n_u_outreallowerband}; - __pyx_mstate_global->__pyx_codeobj_tab[26] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_BBANDS, __pyx_k_VVmmn4_aq_T_q_8_T_U_7_A_we_b_Zz, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[26])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[26] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_BBANDS, __pyx_mstate->__pyx_kp_b_iso88591_VVmmn4_aq_T_q_8_T_U_7_A_we_b_Zz, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[26])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 668, 209}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 668}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[27] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_BETA, __pyx_k_BC_Kq_Kq_7_8_U_E_U_7_A_we_Ba_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[27])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[27] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_BETA, __pyx_mstate->__pyx_kp_b_iso88591_BC_Kq_Kq_7_8_U_E_U_7_A_we_Ba_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[27])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 701, 298}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 701}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[28] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_BOP, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[28])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[28] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_BOP, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[28])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 733, 255}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 733}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[29] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CCI, __pyx_k_Z_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[29])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[29] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CCI, __pyx_mstate->__pyx_kp_b_iso88591_Z_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[29])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 766, 302}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 766}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[30] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDL2CROWS, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[30])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[30] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDL2CROWS, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[30])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 798, 308}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 798}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[31] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDL3BLACKCROWS, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[31])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[31] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDL3BLACKCROWS, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[31])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 830, 306}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 830}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[32] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDL3INSIDE, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_5, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[32])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[32] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDL3INSIDE, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_5, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[32])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 862, 308}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 862}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[33] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDL3LINESTRIKE, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[33])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[33] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDL3LINESTRIKE, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[33])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 894, 306}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 894}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[34] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDL3OUTSIDE, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[34])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[34] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDL3OUTSIDE, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[34])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 926, 312}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 926}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[35] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDL3STARSINSOUTH, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_7, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[35])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[35] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDL3STARSINSOUTH, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_7, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[35])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 958, 312}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 958}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[36] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDL3WHITESOLDIERS, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_8, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[36])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[36] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDL3WHITESOLDIERS, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_8, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[36])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 990, 328}; + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 990}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[37] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLABANDONEDBABY, __pyx_k_C_D_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[37])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[37] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLABANDONEDBABY, __pyx_mstate->__pyx_kp_b_iso88591_C_D_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[37])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1024, 308}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1024}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[38] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLADVANCEBLOCK, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_9, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[38])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[38] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLADVANCEBLOCK, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_9, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[38])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1056, 306}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1056}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[39] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLBELTHOLD, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[39])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[39] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLBELTHOLD, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[39])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1088, 307}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1088}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[40] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLBREAKAWAY, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_10, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[40])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[40] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLBREAKAWAY, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_10, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[40])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1120, 312}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1120}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[41] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLCLOSINGMARUBOZU, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[41])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[41] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLCLOSINGMARUBOZU, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[41])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1152, 316}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1152}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[42] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLCONCEALBABYSWALL, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_12, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[42])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[42] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLCONCEALBABYSWALL, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_12, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[42])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1184, 312}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1184}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[43] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLCOUNTERATTACK, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_7, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[43])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[43] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLCOUNTERATTACK, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_7, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[43])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1216, 328}; + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1216}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[44] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLDARKCLOUDCOVER, __pyx_k_D_E_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[44])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[44] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLDARKCLOUDCOVER, __pyx_mstate->__pyx_kp_b_iso88591_D_E_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[44])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1250, 297}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1250}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[45] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLDOJI, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_13, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[45])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[45] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLDOJI, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_13, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[45])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1282, 306}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1282}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[46] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLDOJISTAR, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[46])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[46] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLDOJISTAR, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[46])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1314, 312}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1314}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[47] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLDRAGONFLYDOJI, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_7, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[47])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[47] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLDRAGONFLYDOJI, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_7, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[47])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1346, 307}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1346}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[48] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLENGULFING, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_10, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[48])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[48] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLENGULFING, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_10, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[48])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1378, 328}; + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1378}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[49] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLEVENINGDOJISTAR, __pyx_k_E_F_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[49])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[49] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLEVENINGDOJISTAR, __pyx_mstate->__pyx_kp_b_iso88591_E_F_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[49])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1412, 324}; + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1412}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[50] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLEVENINGSTAR, __pyx_k_A_B_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[50])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[50] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLEVENINGSTAR, __pyx_mstate->__pyx_kp_b_iso88591_A_B_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[50])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1446, 316}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1446}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[51] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLGAPSIDESIDEWHITE, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_12, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[51])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[51] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLGAPSIDESIDEWHITE, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_12, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[51])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1478, 312}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1478}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[52] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLGRAVESTONEDOJI, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_8, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[52])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[52] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLGRAVESTONEDOJI, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_8, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[52])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1510, 302}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1510}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[53] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHAMMER, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[53])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[53] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHAMMER, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[53])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1542, 308}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1542}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[54] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHANGINGMAN, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_14, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[54])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[54] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHANGINGMAN, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_14, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[54])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1574, 302}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1574}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[55] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHARAMI, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[55])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[55] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHARAMI, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[55])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1606, 308}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1606}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[56] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHARAMICROSS, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[56])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[56] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHARAMICROSS, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[56])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1638, 306}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1638}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[57] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHIGHWAVE, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[57])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[57] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHIGHWAVE, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[57])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1670, 306}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1670}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[58] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHIKKAKE, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_5, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[58])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[58] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHIKKAKE, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_5, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[58])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1702, 308}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1702}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[59] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHIKKAKEMOD, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_14, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[59])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[59] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHIKKAKEMOD, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_14, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[59])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1734, 308}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1734}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[60] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHOMINGPIGEON, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_9, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[60])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[60] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHOMINGPIGEON, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_9, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[60])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1766, 312}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1766}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[61] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLIDENTICAL3CROWS, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[61])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[61] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLIDENTICAL3CROWS, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[61])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1798, 302}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1798}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[62] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLINNECK, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[62])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[62] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLINNECK, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[62])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1830, 312}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1830}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[63] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLINVERTEDHAMMER, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_8, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[63])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[63] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLINVERTEDHAMMER, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_8, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[63])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1862, 306}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1862}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[64] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLKICKING, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_5, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[64])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[64] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLKICKING, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_5, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[64])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1894, 312}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1894}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[65] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLKICKINGBYLENGTH, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[65])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[65] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLKICKINGBYLENGTH, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[65])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1926, 308}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1926}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[66] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLLADDERBOTTOM, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_9, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[66])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[66] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLLADDERBOTTOM, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_9, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[66])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1958, 312}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1958}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[67] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLLONGLEGGEDDOJI, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_8, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[67])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[67] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLLONGLEGGEDDOJI, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_8, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[67])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1990, 306}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1990}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[68] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLLONGLINE, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[68])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[68] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLLONGLINE, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[68])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2022, 306}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2022}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[69] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLMARUBOZU, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[69])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[69] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLMARUBOZU, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[69])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2054, 308}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2054}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[70] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLMATCHINGLOW, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[70])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[70] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLMATCHINGLOW, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[70])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2086, 318}; + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2086}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[71] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLMATHOLD, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_15, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[71])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[71] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLMATHOLD, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_15, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[71])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2120, 328}; + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2120}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[72] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLMORNINGDOJISTAR, __pyx_k_E_F_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[72])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[72] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLMORNINGDOJISTAR, __pyx_mstate->__pyx_kp_b_iso88591_E_F_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[72])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2154, 324}; + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2154}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[73] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLMORNINGSTAR, __pyx_k_A_B_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[73])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[73] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLMORNINGSTAR, __pyx_mstate->__pyx_kp_b_iso88591_A_B_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[73])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2188, 302}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2188}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[74] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLONNECK, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[74])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[74] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLONNECK, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[74])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2220, 306}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2220}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[75] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLPIERCING, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[75])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[75] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLPIERCING, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[75])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2252, 308}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2252}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[76] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLRICKSHAWMAN, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[76])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[76] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLRICKSHAWMAN, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[76])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2284, 316}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2284}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[77] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLRISEFALL3METHODS, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_12, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[77])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[77] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLRISEFALL3METHODS, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_12, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[77])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2316, 312}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2316}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[78] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLSEPARATINGLINES, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[78])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[78] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLSEPARATINGLINES, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[78])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2348, 308}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2348}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[79] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLSHOOTINGSTAR, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_9, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[79])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[79] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLSHOOTINGSTAR, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_9, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[79])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2380, 307}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2380}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[80] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLSHORTLINE, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_10, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[80])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[80] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLSHORTLINE, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_10, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[80])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2412, 308}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2412}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[81] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLSPINNINGTOP, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[81])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[81] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLSPINNINGTOP, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[81])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2444, 312}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2444}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[82] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLSTALLEDPATTERN, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_8, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[82])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[82] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLSTALLEDPATTERN, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_8, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[82])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2476, 312}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2476}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[83] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLSTICKSANDWICH, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_7, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[83])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[83] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLSTICKSANDWICH, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_7, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[83])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2508, 302}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2508}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[84] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLTAKURI, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[84])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[84] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLTAKURI, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[84])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2540, 307}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2540}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[85] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLTASUKIGAP, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_10, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[85])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[85] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLTASUKIGAP, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_10, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[85])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2572, 307}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2572}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[86] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLTHRUSTING, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_10, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[86])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[86] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLTHRUSTING, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_10, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[86])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2604, 306}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2604}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[87] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLTRISTAR, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_5, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[87])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[87] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLTRISTAR, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_5, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[87])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2636, 308}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2636}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[88] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLUNIQUE3RIVER, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_9, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[88])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[88] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLUNIQUE3RIVER, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_9, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[88])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2668, 312}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2668}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[89] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLUPSIDEGAP2CROWS, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[89])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[89] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLUPSIDEGAP2CROWS, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[89])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2700, 316}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2700}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[90] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLXSIDEGAP3METHODS, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_12, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[90])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[90] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLXSIDEGAP3METHODS, __pyx_mstate->__pyx_kp_b_iso88591_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_12, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[90])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2732, 138}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2732}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[91] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CEIL, __pyx_k_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[91])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[91] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CEIL, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[91])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2761, 163}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2761}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[92] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CMO, __pyx_k_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[92])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[92] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CMO, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[92])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2792, 209}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2792}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[93] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CORREL, __pyx_k_DE_Kq_Kq_7_8_U_E_U_7_A_we_b_q_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[93])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[93] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CORREL, __pyx_mstate->__pyx_kp_b_iso88591_DE_Kq_Kq_7_8_U_E_U_7_A_we_b_q_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[93])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2825, 138}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2825}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[94] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_COS, __pyx_k_aq_T_q_8_T_U_7_A_we_1_q_i_fAYa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[94])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[94] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_COS, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_1_q_i_fAYa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[94])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2854, 138}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2854}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[95] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_COSH, __pyx_k_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[95])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[95] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_COSH, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[95])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2883, 163}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2883}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[96] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_DEMA, __pyx_k_aq_T_q_8_T_U_7_A_we_Ba_q_4y_4vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[96])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[96] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_DEMA, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_Ba_q_4y_4vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[96])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2914, 193}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2914}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[97] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_DIV, __pyx_k_Kq_Kq_7_8_U_E_U_7_A_we_1_q_i_vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[97])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[97] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_DIV, __pyx_mstate->__pyx_kp_b_iso88591_Kq_Kq_7_8_U_E_U_7_A_we_1_q_i_vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[97])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2945, 254}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2945}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[98] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_DX, __pyx_k_YZ_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[98])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[98] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_DX, __pyx_mstate->__pyx_kp_b_iso88591_YZ_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[98])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2978, 163}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2978}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[99] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_EMA, __pyx_k_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[99])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[99] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_EMA, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[99])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3009, 138}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3009}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[100] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_EXP, __pyx_k_aq_T_q_8_T_U_7_A_we_1_q_i_fAYa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[100])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[100] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_EXP, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_1_q_i_fAYa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[100])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3038, 138}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3038}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[101] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_FLOOR, __pyx_k_aq_T_q_8_T_U_7_A_we_Q_q_D_D_ay, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[101])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[101] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_FLOOR, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_Q_q_D_D_ay, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[101])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3067, 151}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3067}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[102] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_HT_DCPERIOD, __pyx_k_aq_T_q_8_T_U_7_A_we_31_q_i_fAYa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[102])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[102] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_HT_DCPERIOD, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_31_q_i_fAYa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[102])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3096, 151}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3096}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[103] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_HT_DCPHASE, __pyx_k_aq_T_q_8_T_U_7_A_we_2_q_r_Yk_V1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[103])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[103] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_HT_DCPHASE, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_2_q_r_Yk_V1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[103])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3125, 200}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3125}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinphase, __pyx_mstate->__pyx_n_u_outquadrature}; - __pyx_mstate_global->__pyx_codeobj_tab[104] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_HT_PHASOR, __pyx_k_aq_T_q_8_T_U_7_A_we_1_81_Qha_b, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[104])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[104] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_HT_PHASOR, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_1_81_Qha_b, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[104])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3157, 195}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3157}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outsine, __pyx_mstate->__pyx_n_u_outleadsine}; - __pyx_mstate_global->__pyx_codeobj_tab[105] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_HT_SINE, __pyx_k_aq_T_q_8_T_U_7_A_we_q_q_1HA_Bd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[105])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[105] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_HT_SINE, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_q_q_1HA_Bd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[105])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3189, 153}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3189}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[106] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_HT_TRENDLINE, __pyx_k_aq_T_q_8_T_U_7_A_we_4A_q_4y_4vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[106])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[106] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_HT_TRENDLINE, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_4A_q_4y_4vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[106])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3218, 152}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3218}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[107] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_HT_TRENDMODE, __pyx_k_aq_T_q_8_T_U_7_A_we_4A_q_4y_4vQ_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[107])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[107] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_HT_TRENDMODE, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_4A_q_4y_4vQ_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[107])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3247, 209}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3247}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[108] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_IMI, __pyx_k_A_aq_Kq_6_8_T_5_U_7_A_we_2Q_q_i, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[108])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[108] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_IMI, __pyx_mstate->__pyx_kp_b_iso88591_A_aq_Kq_6_8_T_5_U_7_A_we_2Q_q_i, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[108])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3279, 163}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3279}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[109] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_KAMA, __pyx_k_aq_T_q_8_T_U_7_A_we_Ba_q_4y_4vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[109])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[109] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_KAMA, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_Ba_q_4y_4vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[109])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3310, 168}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3310}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[110] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_LINEARREG, __pyx_k_aq_T_q_8_T_U_7_A_we_1_1_q_b_I_F, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[110])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[110] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_LINEARREG, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_1_1_q_b_I_F, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[110])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3341, 170}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3341}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[111] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_LINEARREG_ANGLE, __pyx_k_01_aq_T_q_8_T_U_7_A_we_7r_q_Bd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[111])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[111] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_LINEARREG_ANGLE, __pyx_mstate->__pyx_kp_b_iso88591_01_aq_T_q_8_T_U_7_A_we_7r_q_Bd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[111])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3372, 174}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3372}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[112] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_LINEARREG_INTERCEPT, __pyx_k_45_aq_T_q_8_T_U_7_A_we_2Q_q_i_f, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[112])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[112] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_LINEARREG_INTERCEPT, __pyx_mstate->__pyx_kp_b_iso88591_45_aq_T_q_8_T_U_7_A_we_2Q_q_i_f, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[112])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3403, 170}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3403}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[113] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_LINEARREG_SLOPE, __pyx_k_01_aq_T_q_8_T_U_7_A_we_7r_q_Bd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[113])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[113] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_LINEARREG_SLOPE, __pyx_mstate->__pyx_kp_b_iso88591_01_aq_T_q_8_T_U_7_A_we_7r_q_Bd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[113])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3434, 137}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3434}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[114] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_LN, __pyx_k_aq_T_q_8_T_U_7_A_we_q_r_Yk_V1IQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[114])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[114] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_LN, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_q_r_Yk_V1IQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[114])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3463, 138}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3463}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[115] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_LOG10, __pyx_k_aq_T_q_8_T_U_7_A_we_Q_q_D_D_ay, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[115])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[115] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_LOG10, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_Q_q_D_D_ay, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[115])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3492, 173}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3492}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[116] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MA, __pyx_k_1_aq_T_q_8_T_U_7_A_we_M_q_r_Yk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[116])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[116] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MA, __pyx_mstate->__pyx_kp_b_iso88591_1_aq_T_q_8_T_U_7_A_we_M_q_r_Yk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[116])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3524, 286}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3524}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_fastperiod, __pyx_mstate->__pyx_n_u_slowperiod, __pyx_mstate->__pyx_n_u_signalperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outmacd, __pyx_mstate->__pyx_n_u_outmacdsignal, __pyx_mstate->__pyx_n_u_outmacdhist}; - __pyx_mstate_global->__pyx_codeobj_tab[117] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MACD, __pyx_k_UUV2_aq_T_q_8_T_U_7_A_we_Bm_q_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[117])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[117] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MACD, __pyx_mstate->__pyx_kp_b_iso88591_UUV2_aq_T_q_8_T_U_7_A_we_Bm_q_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[117])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {7, 0, 0, 17, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3563, 341}; + const __Pyx_PyCode_New_function_description descr = {7, 0, 0, 17, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3563}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_fastperiod, __pyx_mstate->__pyx_n_u_fastmatype, __pyx_mstate->__pyx_n_u_slowperiod, __pyx_mstate->__pyx_n_u_slowmatype, __pyx_mstate->__pyx_n_u_signalperiod, __pyx_mstate->__pyx_n_u_signalmatype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outmacd, __pyx_mstate->__pyx_n_u_outmacdsignal, __pyx_mstate->__pyx_n_u_outmacdhist}; - __pyx_mstate_global->__pyx_codeobj_tab[118] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MACDEXT, __pyx_k_SSkk_Y_Y_Z_8_aq_T_q_8_T_U_7_A_w, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[118])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[118] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MACDEXT, __pyx_mstate->__pyx_kp_b_iso88591_SSkk_Y_Y_Z_8_aq_T_q_8_T_U_7_A_w, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[118])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3605, 266}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3605}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_signalperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outmacd, __pyx_mstate->__pyx_n_u_outmacdsignal, __pyx_mstate->__pyx_n_u_outmacdhist}; - __pyx_mstate_global->__pyx_codeobj_tab[119] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MACDFIX, __pyx_k_aq_T_q_8_T_U_7_A_we_r_q_Qha_1HA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[119])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[119] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MACDFIX, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_r_q_Qha_1HA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[119])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3642, 223}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3642}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_fastlimit, __pyx_mstate->__pyx_n_u_slowlimit, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outmama, __pyx_mstate->__pyx_n_u_outfama}; - __pyx_mstate_global->__pyx_codeobj_tab[120] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MAMA, __pyx_k_a_aq_T_q_8_T_U_7_A_we_Bl_q_q_4y, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[120])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[120] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MAMA, __pyx_mstate->__pyx_kp_b_iso88591_a_aq_T_q_8_T_U_7_A_we_Bl_q_q_4y, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[120])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3677, 237}; + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3677}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_periods, __pyx_mstate->__pyx_n_u_minperiod, __pyx_mstate->__pyx_n_u_maxperiod, __pyx_mstate->__pyx_n_u_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[121] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MAVP, __pyx_k_CZZqqr_aq_k_6_8_T_7_U_7_A_we_Bl, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[121])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[121] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MAVP, __pyx_mstate->__pyx_kp_b_iso88591_CZZqqr_aq_k_6_8_T_7_U_7_A_we_Bl, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[121])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3712, 163}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3712}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[122] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MAX, __pyx_k_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[122])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[122] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MAX, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[122])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3743, 190}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3743}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger, __pyx_mstate->__pyx_n_u_outinteger_data, __pyx_mstate->__pyx_n_u_i}; - __pyx_mstate_global->__pyx_codeobj_tab[123] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MAXINDEX, __pyx_k_aq_T_q_8_T_U_7_A_we_0_q_Rt9Kt6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[123])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[123] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MAXINDEX, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_0_q_Rt9Kt6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[123])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3777, 193}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3777}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[124] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MEDPRICE, __pyx_k_aq_Qa_6_8_T_3a_U_7_A_we_0_q_Rt9, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[124])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[124] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MEDPRICE, __pyx_mstate->__pyx_kp_b_iso88591_aq_Qa_6_8_T_3a_U_7_A_we_0_q_Rt9, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[124])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3807, 310}; + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3807}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_volume, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[125] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MFI, __pyx_k_wx_aq_Qa_Kq_6_gQ_8_T_3hjX_eeoou, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[125])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[125] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MFI, __pyx_mstate->__pyx_kp_b_iso88591_wx_aq_Qa_Kq_6_gQ_8_T_3hjX_eeoou, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[125])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3841, 167}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3841}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[126] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MIDPOINT, __pyx_k_aq_T_q_8_T_U_7_A_we_0_q_Rt9Kt6_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[126])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[126] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MIDPOINT, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_0_q_Rt9Kt6_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[126])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3872, 209}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3872}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[127] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MIDPRICE, __pyx_k_CD_aq_Qa_6_8_T_3a_U_7_A_we_0_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[127])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[127] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MIDPRICE, __pyx_mstate->__pyx_kp_b_iso88591_CD_aq_Qa_6_8_T_3a_U_7_A_we_0_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[127])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3904, 163}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3904}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[128] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MIN, __pyx_k_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[128])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[128] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MIN, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[128])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3935, 190}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3935}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger, __pyx_mstate->__pyx_n_u_outinteger_data, __pyx_mstate->__pyx_n_u_i}; - __pyx_mstate_global->__pyx_codeobj_tab[129] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MININDEX, __pyx_k_aq_T_q_8_T_U_7_A_we_0_q_Rt9Kt6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[129])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[129] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MININDEX, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_0_q_Rt9Kt6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[129])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3969, 212}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3969}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outmin, __pyx_mstate->__pyx_n_u_outmax}; - __pyx_mstate_global->__pyx_codeobj_tab[130] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MINMAX, __pyx_k_aq_T_q_8_T_U_7_A_we_b_axq_axq_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[130])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[130] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MINMAX, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_b_axq_axq_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[130])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4003, 271}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4003}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outminidx, __pyx_mstate->__pyx_n_u_outmaxidx, __pyx_mstate->__pyx_n_u_outminidx_data, __pyx_mstate->__pyx_n_u_i, __pyx_mstate->__pyx_n_u_outmaxidx_data}; - __pyx_mstate_global->__pyx_codeobj_tab[131] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MINMAXINDEX, __pyx_k_aq_T_q_8_T_U_7_A_we_32Q_axq_axq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[131])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[131] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MINMAXINDEX, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_32Q_axq_axq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[131])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4043, 259}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4043}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[132] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MINUS_DI, __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[132])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[132] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MINUS_DI, __pyx_mstate->__pyx_kp_b_iso88591_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[132])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4076, 209}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4076}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[133] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MINUS_DM, __pyx_k_CD_aq_Qa_6_8_T_3a_U_7_A_we_0_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[133])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[133] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MINUS_DM, __pyx_mstate->__pyx_kp_b_iso88591_CD_aq_Qa_6_8_T_3a_U_7_A_we_0_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[133])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4108, 163}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4108}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[134] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MOM, __pyx_k_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[134])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[134] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MOM, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[134])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4139, 193}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4139}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[135] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MULT, __pyx_k_Kq_Kq_7_8_U_E_U_7_A_we_A_q_4y_5, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[135])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[135] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MULT, __pyx_mstate->__pyx_kp_b_iso88591_Kq_Kq_7_8_U_E_U_7_A_we_A_q_4y_5, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[135])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4170, 255}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4170}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[136] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_NATR, __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[136])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[136] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_NATR, __pyx_mstate->__pyx_kp_b_iso88591_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[136])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4203, 193}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4203}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_volume, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[137] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_OBV, __pyx_k_aq_6_8_T_6_U_7_A_we_1_q_i_fAYkQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[137])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[137] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_OBV, __pyx_mstate->__pyx_kp_b_iso88591_aq_6_8_T_6_U_7_A_we_1_q_i_fAYkQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[137])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4234, 255}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4234}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[138] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_PLUS_DI, __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[138])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[138] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_PLUS_DI, __pyx_mstate->__pyx_kp_b_iso88591_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[138])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4267, 209}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4267}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[139] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_PLUS_DM, __pyx_k_BC_aq_Qa_6_8_T_3a_U_7_A_we_r_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[139])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[139] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_PLUS_DM, __pyx_mstate->__pyx_kp_b_iso88591_BC_aq_Qa_6_8_T_3a_U_7_A_we_r_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[139])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4299, 187}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4299}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_fastperiod, __pyx_mstate->__pyx_n_u_slowperiod, __pyx_mstate->__pyx_n_u_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[140] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_PPO, __pyx_k_TTU_aq_T_q_8_T_U_7_A_we_2_q_q_i, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[140])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[140] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_PPO, __pyx_mstate->__pyx_kp_b_iso88591_TTU_aq_T_q_8_T_U_7_A_we_2_q_q_i, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[140])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4332, 163}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4332}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[141] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ROC, __pyx_k_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[141])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[141] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ROC, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[141])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4363, 163}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4363}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[142] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ROCP, __pyx_k_aq_T_q_8_T_U_7_A_we_Ba_q_4y_4vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[142])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[142] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ROCP, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_Ba_q_4y_4vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[142])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4394, 163}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4394}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[143] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ROCR, __pyx_k_aq_T_q_8_T_U_7_A_we_Ba_q_4y_4vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[143])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[143] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ROCR, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_Ba_q_4y_4vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[143])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4425, 163}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4425}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[144] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ROCR100, __pyx_k_aq_T_q_8_T_U_7_A_we_r_q_Bd_d_WX, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[144])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[144] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ROCR100, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_r_q_Bd_d_WX, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[144])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4456, 163}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4456}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[145] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_RSI, __pyx_k_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[145])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[145] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_RSI, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[145])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4487, 217}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4487}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_acceleration, __pyx_mstate->__pyx_n_u_maximum, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[146] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SAR, __pyx_k_YYZ_aq_Qa_6_8_T_3a_U_7_A_we_2_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[146])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[146] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SAR, __pyx_mstate->__pyx_kp_b_iso88591_YYZ_aq_Qa_6_8_T_3a_U_7_A_we_2_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[146])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {10, 0, 0, 18, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4520, 344}; + const __Pyx_PyCode_New_function_description descr = {10, 0, 0, 18, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4520}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_startvalue, __pyx_mstate->__pyx_n_u_offsetonreverse, __pyx_mstate->__pyx_n_u_accelerationinitlong, __pyx_mstate->__pyx_n_u_accelerationlong, __pyx_mstate->__pyx_n_u_accelerationmaxlong, __pyx_mstate->__pyx_n_u_accelerationinitshort, __pyx_mstate->__pyx_n_u_accelerationshort, __pyx_mstate->__pyx_n_u_accelerationmaxshort, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[147] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SAREXT, __pyx_k_A_z_____b_b_G_G_h_h_i_4_aq_Qa_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[147])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[147] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SAREXT, __pyx_mstate->__pyx_kp_b_iso88591_A_z_____b_b_G_G_h_h_i_4_aq_Qa_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[147])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4559, 138}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4559}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[148] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SIN, __pyx_k_aq_T_q_8_T_U_7_A_we_1_q_i_fAYa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[148])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[148] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SIN, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_1_q_i_fAYa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[148])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4588, 138}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4588}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[149] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SINH, __pyx_k_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[149])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[149] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SINH, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[149])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4617, 163}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4617}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[150] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SMA, __pyx_k_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[150])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[150] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SMA, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[150])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4648, 138}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4648}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[151] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SQRT, __pyx_k_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[151])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[151] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SQRT, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[151])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4677, 174}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4677}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_nbdev, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[152] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_STDDEV, __pyx_k_q_aq_T_q_8_T_U_7_A_we_b_Q_q_2T, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[152])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[152] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_STDDEV, __pyx_mstate->__pyx_kp_b_iso88591_q_aq_T_q_8_T_U_7_A_we_b_Q_q_2T, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[152])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {8, 0, 0, 17, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4709, 370}; + const __Pyx_PyCode_New_function_description descr = {8, 0, 0, 17, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4709}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_fastk_period, __pyx_mstate->__pyx_n_u_slowk_period, __pyx_mstate->__pyx_n_u_slowk_matype, __pyx_mstate->__pyx_n_u_slowd_period, __pyx_mstate->__pyx_n_u_slowd_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outslowk, __pyx_mstate->__pyx_n_u_outslowd}; - __pyx_mstate_global->__pyx_codeobj_tab[153] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_STOCH, __pyx_k_v_w_Q_Q_f_f_A_2_aq_Qa_Kq_6_a_8, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[153])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[153] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_STOCH, __pyx_mstate->__pyx_kp_b_iso88591_v_w_Q_Q_f_f_A_2_aq_Qa_Kq_6_a_8, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[153])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {6, 0, 0, 15, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4749, 336}; + const __Pyx_PyCode_New_function_description descr = {6, 0, 0, 15, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4749}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_fastk_period, __pyx_mstate->__pyx_n_u_fastd_period, __pyx_mstate->__pyx_n_u_fastd_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outfastk, __pyx_mstate->__pyx_n_u_outfastd}; - __pyx_mstate_global->__pyx_codeobj_tab[154] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_STOCHF, __pyx_k_w_x_R_R_S_aq_Qa_Kq_6_a_8_T_3hjX, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[154])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[154] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_STOCHF, __pyx_mstate->__pyx_kp_b_iso88591_w_x_R_R_S_aq_Qa_Kq_6_a_8_T_3hjX, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[154])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4787, 261}; + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4787}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_fastk_period, __pyx_mstate->__pyx_n_u_fastd_period, __pyx_mstate->__pyx_n_u_fastd_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outfastk, __pyx_mstate->__pyx_n_u_outfastd}; - __pyx_mstate_global->__pyx_codeobj_tab[155] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_STOCHRSI, __pyx_k_AA_uuv0_aq_T_q_8_T_U_7_A_we_0_o, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[155])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[155] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_STOCHRSI, __pyx_mstate->__pyx_kp_b_iso88591_AA_uuv0_aq_T_q_8_T_U_7_A_we_0_o, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[155])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4824, 193}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4824}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[156] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SUB, __pyx_k_Kq_Kq_7_8_U_E_U_7_A_we_1_q_i_vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[156])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[156] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SUB, __pyx_mstate->__pyx_kp_b_iso88591_Kq_Kq_7_8_U_E_U_7_A_we_1_q_i_vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[156])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4855, 163}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4855}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[157] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SUM, __pyx_k_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[157])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[157] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SUM, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[157])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4886, 173}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4886}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_vfactor, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[158] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_T3, __pyx_k_1_aq_T_q_8_T_U_7_A_we_M_q_r_Yk_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[158])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[158] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_T3, __pyx_mstate->__pyx_kp_b_iso88591_1_aq_T_q_8_T_U_7_A_we_M_q_r_Yk_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[158])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4918, 138}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4918}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[159] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TAN, __pyx_k_aq_T_q_8_T_U_7_A_we_1_q_i_fAYa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[159])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[159] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TAN, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_1_q_i_fAYa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[159])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4947, 138}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4947}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[160] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TANH, __pyx_k_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[160])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[160] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TANH, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[160])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4976, 163}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4976}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[161] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TEMA, __pyx_k_aq_T_q_8_T_U_7_A_we_Ba_q_4y_4vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[161])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[161] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TEMA, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_Ba_q_4y_4vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[161])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5007, 243}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5007}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[162] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TRANGE, __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[162])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[162] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TRANGE, __pyx_mstate->__pyx_kp_b_iso88591_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[162])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5038, 163}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5038}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[163] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TRIMA, __pyx_k_aq_T_q_8_T_U_7_A_we_Rq_q_D_D_ay, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[163])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[163] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TRIMA, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_Rq_q_D_D_ay, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[163])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5069, 163}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5069}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[164] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TRIX, __pyx_k_aq_T_q_8_T_U_7_A_we_Ba_q_4y_4vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[164])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[164] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TRIX, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_Ba_q_4y_4vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[164])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5100, 163}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5100}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[165] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TSF, __pyx_k_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[165])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[165] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TSF, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[165])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5131, 247}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5131}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[166] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TYPPRICE, __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[166])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[166] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TYPPRICE, __pyx_mstate->__pyx_kp_b_iso88591_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[166])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {6, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5162, 287}; + const __Pyx_PyCode_New_function_description descr = {6, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5162}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod1, __pyx_mstate->__pyx_n_u_timeperiod2, __pyx_mstate->__pyx_n_u_timeperiod3, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[167] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ULTOSC, __pyx_k_v_w_P_P_Q_aq_Qa_Kq_6_a_8_T_3hjX, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[167])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[167] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ULTOSC, __pyx_mstate->__pyx_kp_b_iso88591_v_w_P_P_Q_aq_Qa_Kq_6_a_8_T_3hjX, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[167])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5197, 174}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5197}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_nbdev, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[168] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_VAR, __pyx_k_A_aq_T_q_8_T_U_7_A_we_2_q_i_fAY, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[168])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[168] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_VAR, __pyx_mstate->__pyx_kp_b_iso88591_A_aq_T_q_8_T_U_7_A_we_2_q_i_fAY, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[168])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5229, 247}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5229}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[169] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_WCLPRICE, __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[169])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[169] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_WCLPRICE, __pyx_mstate->__pyx_kp_b_iso88591_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[169])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5260, 255}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5260}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[170] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_WILLR, __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[170])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[170] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_WILLR, __pyx_mstate->__pyx_kp_b_iso88591_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[170])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5293, 163}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5293}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[171] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_WMA, __pyx_k_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[171])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[171] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_WMA, __pyx_mstate->__pyx_kp_b_iso88591_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[171])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 74, 13}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 74}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_s}; - __pyx_mstate_global->__pyx_codeobj_tab[172] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_str2bytes, __pyx_k_A_uAS, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[172])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[172] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_str2bytes, __pyx_mstate->__pyx_kp_b_iso88591_A_uAS, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[172])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 77, 13}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 77}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_b}; - __pyx_mstate_global->__pyx_codeobj_tab[173] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_bytes2str, __pyx_k_A_q_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[173])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[173] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_bytes2str, __pyx_mstate->__pyx_kp_b_iso88591_A_q_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[173])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 82, 7}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 82}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_s}; - __pyx_mstate_global->__pyx_codeobj_tab[174] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_str2bytes, __pyx_k_A_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[174])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[174] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_str2bytes, __pyx_mstate->__pyx_kp_b_iso88591_A_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[174])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 85, 7}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 85}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_b}; - __pyx_mstate_global->__pyx_codeobj_tab[175] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_bytes2str, __pyx_k_A_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[175])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[175] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_bytes2str, __pyx_mstate->__pyx_kp_b_iso88591_A_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[175])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS), 117, 69}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS), 117}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_function_name, __pyx_mstate->__pyx_n_u_func_object, __pyx_mstate->__pyx_n_u_args, __pyx_mstate->__pyx_n_u_kwargs}; - __pyx_mstate_global->__pyx_codeobj_tab[176] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_init, __pyx_k_A_Jm6_M_Q_Jiq_A_O9F_b_O1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[176])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[176] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_init, __pyx_mstate->__pyx_kp_b_iso88591_A_Jm6_M_Q_Jiq_A_O9F_b_O1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[176])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 130, 363}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 130}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_i, __pyx_mstate->__pyx_n_u_info, __pyx_mstate->__pyx_n_u_input_name, __pyx_mstate->__pyx_n_u_param_name, __pyx_mstate->__pyx_n_u_output_name}; - __pyx_mstate_global->__pyx_codeobj_tab[177] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_local_2, __pyx_k_A_A_4wawa_1_Kq_Q_V1E_d_1_0_Ya_T, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[177])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[177] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_local_2, __pyx_mstate->__pyx_kp_b_iso88591_A_A_4wawa_1_Kq_Q_V1E_d_1_0_Ya_T, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[177])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 172, 17}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 172}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; - __pyx_mstate_global->__pyx_codeobj_tab[178] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_info, __pyx_k_A_t85_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[178])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[178] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_info, __pyx_mstate->__pyx_kp_b_iso88591_A_t85_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[178])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 179, 17}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 179}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; - __pyx_mstate_global->__pyx_codeobj_tab[179] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_function_flags, __pyx_k_A_t85, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[179])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[179] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_function_flags, __pyx_mstate->__pyx_kp_b_iso88591_A_t85, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[179])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 186, 21}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 186}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; - __pyx_mstate_global->__pyx_codeobj_tab[180] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_output_flags, __pyx_k_A_t85_Q_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[180])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[180] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_output_flags, __pyx_mstate->__pyx_kp_b_iso88591_A_t85_Q_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[180])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 193, 51}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 193}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_ret, __pyx_mstate->__pyx_n_u_input_name}; - __pyx_mstate_global->__pyx_codeobj_tab[181] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_get_input_names, __pyx_k_A_A_k_N_q_q_e_q_1A_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[181])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[181] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_get_input_names, __pyx_mstate->__pyx_kp_b_iso88591_A_A_k_N_q_q_e_q_1A_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[181])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 204, 64}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 204}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_input_names, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_input_name, __pyx_mstate->__pyx_n_u_price_series}; - __pyx_mstate_global->__pyx_codeobj_tab[182] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_set_input_names, __pyx_k_A_A_L_6_Qk_A_a_QnA_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[182])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[182] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_set_input_names, __pyx_mstate->__pyx_kp_b_iso88591_A_A_L_6_Qk_A_a_QnA_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[182])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 216, 56}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 216}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_local}; - __pyx_mstate_global->__pyx_codeobj_tab[183] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_get_input_arrays, __pyx_k_A_A_gQ_5_q_5_V1_5_U, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[183])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[183] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_get_input_arrays, __pyx_mstate->__pyx_kp_b_iso88591_A_A_gQ_5_q_5_V1_5_U, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[183])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 6, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 227, 167}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 6, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 227}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_input_arrays, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_missing_keys, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_missing}; - __pyx_mstate_global->__pyx_codeobj_tab[184] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_set_input_arrays, __pyx_k_A2_A_QnA_1_t_6a_gQ_d_Q_d_1_q_s_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[184])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[184] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_set_input_arrays, __pyx_mstate->__pyx_kp_b_iso88591_A2_A_QnA_1_t_6a_gQ_d_Q_d_1_q_s_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[184])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 276, 48}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 276}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_ret, __pyx_mstate->__pyx_n_u_opt_input}; - __pyx_mstate_global->__pyx_codeobj_tab[185] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_get_parameters, __pyx_k_A_A_k_M_a_q_T_7q_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[185])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[185] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_get_parameters, __pyx_mstate->__pyx_kp_b_iso88591_A_A_k_M_a_q_T_7q_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[185])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 6, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 286, 96}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 6, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 286}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_parameters, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_param, __pyx_mstate->__pyx_n_u_value}; - __pyx_mstate_global->__pyx_codeobj_tab[186] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_set_parameters, __pyx_k_Q_A_1_G9JfA_t_1G1_q_1_a_U_4q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[186])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[186] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_set_parameters, __pyx_mstate->__pyx_kp_b_iso88591_Q_A_1_G9JfA_t_1G1_q_1_a_U_4q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[186])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS), 301, 285}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS), 301}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_args, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_update_info, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_value, __pyx_mstate->__pyx_n_u_skip_first, __pyx_mstate->__pyx_n_u_i, __pyx_mstate->__pyx_n_u_param_name}; - __pyx_mstate_global->__pyx_codeobj_tab[187] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_set_function_args, __pyx_k_A_A_a_G1_t3e1_aq_4_q_Q_AT_V1A_S, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[187])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[187] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_set_function_args, __pyx_mstate->__pyx_kp_b_iso88591_A_A_a_G1_t3e1_aq_4_q_Q_AT_V1A_S, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[187])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 336, 143}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 336}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_holder, __pyx_mstate->__pyx_n_u_i, __pyx_mstate->__pyx_n_u_opt_input, __pyx_mstate->__pyx_n_u_value, __pyx_mstate->__pyx_n_u_type, __pyx_mstate->__pyx_n_u_lookback}; - __pyx_mstate_global->__pyx_codeobj_tab[188] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_lookback, __pyx_k_A_A_at1_C_IQe1_D_aq_E_AZq_vV_2_V, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[188])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[188] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_kp_b_iso88591_A_A_at1_C_IQe1_D_aq_E_AZq_vV_2_V, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[188])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 357, 44}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 357}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_ret}; - __pyx_mstate_global->__pyx_codeobj_tab[189] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_output_names, __pyx_k_A_d_q_4z_q_aq_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[189])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[189] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_output_names, __pyx_mstate->__pyx_kp_b_iso88591_A_d_q_4z_q_aq_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[189])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 367, 241}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 367}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_ret, __pyx_mstate->__pyx_n_u_index}; - __pyx_mstate_global->__pyx_codeobj_tab[190] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_outputs, __pyx_k_A_A_4uA_e87_4z_q_aq_gU_5_q_E_a_s, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[190])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[190] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_outputs, __pyx_mstate->__pyx_kp_b_iso88591_A_A_4uA_e87_4z_q_aq_gU_5_q_E_a_s, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[190])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 399, 36}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 399}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_input_arrays}; - __pyx_mstate_global->__pyx_codeobj_tab[191] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_run, __pyx_k_N_1_A_t1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[191])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[191] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_run, __pyx_mstate->__pyx_kp_b_iso88591_N_1_A_t1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[191])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 16, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS), 411, 497}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 16, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS), 411}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_args, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_opt_input_values, __pyx_mstate->__pyx_n_u_price_series_name_values, __pyx_mstate->__pyx_n_u_input_arrays, __pyx_mstate->__pyx_n_u_input_price_series_names, __pyx_mstate->__pyx_n_u_i, __pyx_mstate->__pyx_n_u_arg, __pyx_mstate->__pyx_n_u_msg, __pyx_mstate->__pyx_n_u_no_existing_input_arrays, __pyx_mstate->__pyx_n_u_param_name, __pyx_mstate->__pyx_n_u_value, __pyx_mstate->__pyx_n_u_input_name, __pyx_mstate->__pyx_n_u_n}; - __pyx_mstate_global->__pyx_codeobj_tab[192] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_call, __pyx_k_A_A_2_k_Qa_e_e1_2S_AQ_U_t1A_q_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[192])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[192] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_call, __pyx_mstate->__pyx_kp_b_iso88591_A_A_2_k_Qa_e_e1_2S_AQ_U_t1A_q_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[192])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 6, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 477, 79}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 6, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 477}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_input_price_series_names, __pyx_mstate->__pyx_n_u_input_name, __pyx_mstate->__pyx_n_u_price_series, __pyx_mstate->__pyx_n_u_name}; - __pyx_mstate_global->__pyx_codeobj_tab[193] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_input_price_series_names_2, __pyx_k_A_A_1_N_q_5_A_z_HA_G1A_q_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[193])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[193] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_input_price_series_names_2, __pyx_mstate->__pyx_kp_b_iso88591_A_A_1_N_q_5_A_z_HA_G1A_q_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[193])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 489, 261}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 489}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_input_price_series_names, __pyx_mstate->__pyx_n_u_args, __pyx_mstate->__pyx_n_u_price_series, __pyx_mstate->__pyx_n_u_series, __pyx_mstate->__pyx_n_u_opt_input, __pyx_mstate->__pyx_n_u_value, __pyx_mstate->__pyx_n_u_results, __pyx_mstate->__pyx_n_u_keys, __pyx_mstate->__pyx_n_u_i, __pyx_mstate->__pyx_n_u_output}; - __pyx_mstate_global->__pyx_codeobj_tab[194] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_call_function, __pyx_k_A_A_4_B_q_A_U_q_we1_axq_wgQa_Q_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[194])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[194] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_call_function, __pyx_mstate->__pyx_kp_b_iso88591_A_A_4_B_q_A_U_q_we1_axq_wgQa_Q_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[194])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 520, 104}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 520}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_input_name, __pyx_mstate->__pyx_n_u_value, __pyx_mstate->__pyx_n_u_type}; - __pyx_mstate_global->__pyx_codeobj_tab[195] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_check_opt_input_value, __pyx_k_A_HKq_1A_6_5Q_A_7_4A_A_QgQ_7_1_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[195])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[195] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_check_opt_input_value, __pyx_mstate->__pyx_kp_b_iso88591_A_HKq_1A_6_5Q_A_7_4A_A_QgQ_7_1_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[195])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 535, 55}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 535}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_input_name, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_value}; - __pyx_mstate_global->__pyx_codeobj_tab[196] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_get_opt_input_value, __pyx_k_A_A_AQ_6_A_E_A_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[196])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[196] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_get_opt_input_value, __pyx_mstate->__pyx_kp_b_iso88591_A_A_AQ_6_A_E_A_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[196])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 545, 13}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 545}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; - __pyx_mstate_global->__pyx_codeobj_tab[197] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_repr, __pyx_k_A_uBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[197])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[197] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_repr, __pyx_mstate->__pyx_kp_b_iso88591_A_uBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[197])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 548, 15}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 548}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; - __pyx_mstate_global->__pyx_codeobj_tab[198] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_unicode, __pyx_k_A_wat81, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[198])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[198] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_unicode, __pyx_mstate->__pyx_kp_b_iso88591_A_wat81, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[198])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 551, 18}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 551}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; - __pyx_mstate_global->__pyx_codeobj_tab[199] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_str, __pyx_k_A_Qd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[199])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[199] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_str, __pyx_mstate->__pyx_kp_b_iso88591_A_Qd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[199])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 565, 78}; + const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 565}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_table, __pyx_mstate->__pyx_n_u_groups, __pyx_mstate->__pyx_n_u_i}; - __pyx_mstate_global->__pyx_codeobj_tab[200] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_ta_getGroupTable, __pyx_k_Q_B_1A_Q_V1E_gQfAU_Q_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[200])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[200] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_ta_getGroupTable, __pyx_mstate->__pyx_kp_b_iso88591_Q_B_1A_Q_V1E_gQfAU_Q_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[200])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 577, 80}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 577}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_group, __pyx_mstate->__pyx_n_u_table, __pyx_mstate->__pyx_n_u_functions, __pyx_mstate->__pyx_n_u_i}; - __pyx_mstate_global->__pyx_codeobj_tab[201] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_ta_getFuncTable, __pyx_k_Q_V1E_q_WAQ_Q_aq_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[201])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[201] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_ta_getFuncTable, __pyx_mstate->__pyx_kp_b_iso88591_Q_V1E_q_WAQ_Q_aq_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[201])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 589, 166}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 589}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_flag, __pyx_mstate->__pyx_n_u_flags_lookup_dict, __pyx_mstate->__pyx_n_u_value_range, __pyx_mstate->__pyx_n_u_min_int, __pyx_mstate->__pyx_n_u_max_int, __pyx_mstate->__pyx_n_u_ret, __pyx_mstate->__pyx_n_u_i}; - __pyx_mstate_global->__pyx_codeobj_tab[202] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_get_flags, __pyx_k_5_t_Qm1_d_1_c_d_3a_Q_c_d_3a_Q_u, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[202])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[202] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_get_flags, __pyx_mstate->__pyx_kp_b_iso88591_5_t_Qm1_d_1_c_d_3a_Q_c_d_3a_Q_u, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[202])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 648, 115}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 648}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_function_name, __pyx_mstate->__pyx_n_u_info, __pyx_mstate->__pyx_n_u_retCode}; - __pyx_mstate_global->__pyx_codeobj_tab[203] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_ta_getFuncInfo, __pyx_k_314DAQ_Q_a_4q_a_Qd_c_a_Qd_s_4q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[203])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[203] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_ta_getFuncInfo, __pyx_mstate->__pyx_kp_b_iso88591_314DAQ_Q_a_4q_a_Qd_c_a_Qd_s_4q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[203])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 667, 121}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 667}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_function_name, __pyx_mstate->__pyx_n_u_idx, __pyx_mstate->__pyx_n_u_info, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_name}; - __pyx_mstate_global->__pyx_codeobj_tab[204] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_ta_getInputParameterInfo, __pyx_k_Q_NeSTTU_Q_2_9AT_4q_1G6_wc_t81H, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[204])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[204] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_ta_getInputParameterInfo, __pyx_mstate->__pyx_kp_b_iso88591_Q_NeSTTU_Q_2_9AT_4q_1G6_wc_t81H, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[204])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 6, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 688, 153}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 6, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 688}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_function_name, __pyx_mstate->__pyx_n_u_idx, __pyx_mstate->__pyx_n_u_info, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_name, __pyx_mstate->__pyx_n_u_default_value}; - __pyx_mstate_global->__pyx_codeobj_tab[205] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_ta_getOptInputParameterInfo, __pyx_k_Q_AQQVVWWX_Q_5Q_9AT_4q_1JfA_D_R, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[205])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[205] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_ta_getOptInputParameterInfo, __pyx_mstate->__pyx_kp_b_iso88591_Q_AQQVVWWX_Q_5Q_9AT_4q_1JfA_Cq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[205])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 712, 121}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 710}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_function_name, __pyx_mstate->__pyx_n_u_idx, __pyx_mstate->__pyx_n_u_info, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_name}; - __pyx_mstate_global->__pyx_codeobj_tab[206] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_ta_getOutputParameterInfo, __pyx_k_1_a_OuTUUV_Q_31_9AT_4q_1HF_wc_d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[206])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[206] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_ta_getOutputParameterInfo, __pyx_mstate->__pyx_kp_b_iso88591_1_a_OuTUUV_Q_31_9AT_4q_1HF_wc_d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[206])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 732, 347}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 730}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_func_info, __pyx_mstate->__pyx_n_u_defaults, __pyx_mstate->__pyx_n_u_func_line, __pyx_mstate->__pyx_n_u_func_args, __pyx_mstate->__pyx_n_u_docs, __pyx_mstate->__pyx_n_u_input_names, __pyx_mstate->__pyx_n_u_input_name, __pyx_mstate->__pyx_n_u_value, __pyx_mstate->__pyx_n_u_params, __pyx_mstate->__pyx_n_u_param, __pyx_mstate->__pyx_n_u_outputs, __pyx_mstate->__pyx_n_u_output, __pyx_mstate->__pyx_n_u_documentation}; - __pyx_mstate_global->__pyx_codeobj_tab[207] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_get_defaults_and_docs, __pyx_k_q_9A_1_q_1_1_1A_q_a_1A_4z_A_G1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[207])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[207] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_get_defaults_and_docs, __pyx_mstate->__pyx_kp_b_iso88591_q_9A_1_q_1_1_1A_q_a_1A_4z_A_G1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[207])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 9, 209}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 9}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outrealupperband, __pyx_mstate->__pyx_n_u_outrealmiddleband, __pyx_mstate->__pyx_n_u_outreallowerband}; - __pyx_mstate_global->__pyx_codeobj_tab[208] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ACCBANDS, __pyx_k_fg2_aq_Q_Qa_y_1_Kq_q_6_a_q_q_Rv, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[208])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[208] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ACCBANDS, __pyx_mstate->__pyx_kp_b_iso88591_fg2_aq_Q_Qa_y_1_Kq_q_6_a_q_q_Rv, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[208])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 50, 94}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 50}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[209] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ACOS, __pyx_k_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[209])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[209] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ACOS, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[209])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 77, 181}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 77}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_volume, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_volume_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[210] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_AD, __pyx_k_aq_Q_Qa_y_1_Kq_q_6_6_gQ_a_r_xr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[210])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[210] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_AD, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_Qa_y_1_Kq_q_6_6_gQ_a_r_xr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[210])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 113, 115}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 113}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real0_data, __pyx_mstate->__pyx_n_u_real1_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[211] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ADD, __pyx_k_Kq_q_Kq_q_7_a_fHBd_iijjyyzz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[211])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[211] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ADD, __pyx_mstate->__pyx_kp_b_iso88591_Kq_q_Kq_q_7_a_fHBd_iijjyyzz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[211])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {6, 0, 0, 15, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 144, 214}; + const __Pyx_PyCode_New_function_description descr = {6, 0, 0, 15, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 144}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_volume, __pyx_mstate->__pyx_n_u_fastperiod, __pyx_mstate->__pyx_n_u_slowperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_volume_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[212] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ADOSC, __pyx_k_A_Y_Y_Z_aq_Q_Qa_y_1_Kq_q_6_6_gQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[212])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[212] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ADOSC, __pyx_mstate->__pyx_kp_b_iso88591_A_Y_Y_Z_aq_Q_Qa_y_1_Kq_q_6_6_gQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[212])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 183, 164}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 183}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[213] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ADX, __pyx_k_ab_aq_Q_Qa_y_1_Kq_q_6_a_a_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[213])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[213] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ADX, __pyx_mstate->__pyx_kp_b_iso88591_ab_aq_Q_Qa_y_1_Kq_q_6_a_a_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[213])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 218, 164}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 218}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[214] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ADXR, __pyx_k_bc_aq_Q_Qa_y_1_Kq_q_6_a_a_6_4vX, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[214])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[214] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ADXR, __pyx_mstate->__pyx_kp_b_iso88591_bc_aq_Q_Qa_y_1_Kq_q_6_a_a_6_4vX, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[214])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 253, 124}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 253}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_fastperiod, __pyx_mstate->__pyx_n_u_slowperiod, __pyx_mstate->__pyx_n_u_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[215] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_APO, __pyx_k_CC_aq_Q_T_q_a_fHBd_m_hhqqrr_O_O, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[215])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[215] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_APO, __pyx_mstate->__pyx_kp_b_iso88591_CC_aq_Q_T_q_a_fHBd_m_hhqqrr_O_O, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[215])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 284, 155}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 284}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outaroondown, __pyx_mstate->__pyx_n_u_outaroonup}; - __pyx_mstate_global->__pyx_codeobj_tab[216] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_AROON, __pyx_k_GH_aq_Q_Qa_y_1_6_1_F_D_hb_LP_hh, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[216])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[216] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_AROON, __pyx_mstate->__pyx_kp_b_iso88591_GH_aq_Q_Qa_y_1_6_1_F_D_hb_LP_hh, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[216])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 319, 134}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 319}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[217] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_AROONOSC, __pyx_k_JK_aq_Q_Qa_y_1_6_a_RvXRt6_4_S_k, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[217])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[217] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_AROONOSC, __pyx_mstate->__pyx_kp_b_iso88591_JK_aq_Q_Qa_y_1_6_a_RvXRt6_4_S_k, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[217])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 351, 94}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 351}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[218] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ASIN, __pyx_k_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[218])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[218] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ASIN, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[218])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 378, 94}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 378}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[219] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ATAN, __pyx_k_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[219])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[219] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ATAN, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[219])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 405, 164}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 405}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[220] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ATR, __pyx_k_ab_aq_Q_Qa_y_1_Kq_q_6_a_a_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[220])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[220] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ATR, __pyx_mstate->__pyx_kp_b_iso88591_ab_aq_Q_Qa_y_1_Kq_q_6_a_a_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[220])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 440, 182}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 440}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[221] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_AVGPRICE, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_a_Rv, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[221])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[221] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_AVGPRICE, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_a_Rv, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[221])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 476, 101}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 476}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[222] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_AVGDEV, __pyx_k_aq_Q_T_q_a_2V82T_xr_Q___kkll_Qm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[222])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[222] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_AVGDEV, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_2V82T_xr_Q___kkll_Qm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[222])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 505, 183}; + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 505}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_nbdevup, __pyx_mstate->__pyx_n_u_nbdevdn, __pyx_mstate->__pyx_n_u_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outrealupperband, __pyx_mstate->__pyx_n_u_outrealmiddleband, __pyx_mstate->__pyx_n_u_outreallowerband}; - __pyx_mstate_global->__pyx_codeobj_tab[223] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_BBANDS, __pyx_k_FF_ttu4_aq_Q_T_q_q_q_2V82T_xr_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[223])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[223] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_BBANDS, __pyx_mstate->__pyx_kp_b_iso88591_FF_ttu4_aq_Q_T_q_q_q_2V82T_xr_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[223])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 543, 134}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 543}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real0_data, __pyx_mstate->__pyx_n_u_real1_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[224] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_BETA, __pyx_k_IJ_Kq_q_Kq_q_7_a_6_4vXRt_P_jjkk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[224])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[224] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_BETA, __pyx_mstate->__pyx_kp_b_iso88591_IJ_Kq_q_Kq_q_7_a_6_4vXRt_P_jjkk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[224])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 576, 177}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 576}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[225] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_BOP, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_a_fH, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[225])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[225] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_BOP, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_a_fH, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[225])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 612, 164}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 612}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[226] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CCI, __pyx_k_ab_aq_Q_Qa_y_1_Kq_q_6_a_a_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[226])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[226] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CCI, __pyx_mstate->__pyx_kp_b_iso88591_ab_aq_Q_Qa_y_1_Kq_q_6_a_a_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[226])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 647, 183}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 647}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[227] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDL2CROWS, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[227])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[227] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDL2CROWS, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[227])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 683, 184}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 683}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[228] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDL3BLACKCROWS, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_2V82, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[228])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[228] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDL3BLACKCROWS, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_2V82, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[228])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 719, 183}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 719}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[229] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDL3INSIDE, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[229])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[229] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDL3INSIDE, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[229])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 755, 184}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 755}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[230] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDL3LINESTRIKE, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_2V82, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[230])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[230] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDL3LINESTRIKE, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_2V82, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[230])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 791, 183}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 791}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[231] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDL3OUTSIDE, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[231])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[231] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDL3OUTSIDE, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[231])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 827, 188}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 827}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[232] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDL3STARSINSOUTH, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_RvXR, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[232])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[232] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDL3STARSINSOUTH, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_RvXR, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[232])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 863, 193}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 863}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[233] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDL3WHITESOLDIERS, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[233])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[233] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDL3WHITESOLDIERS, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[233])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 899, 202}; + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 899}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[234] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLABANDONEDBABY, __pyx_k_J_K_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[234])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[234] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLABANDONEDBABY, __pyx_mstate->__pyx_kp_b_iso88591_J_K_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[234])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 937, 184}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 937}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[235] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLADVANCEBLOCK, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_BfHB, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[235])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[235] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLADVANCEBLOCK, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_BfHB, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[235])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 973, 183}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 973}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[236] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLBELTHOLD, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[236])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[236] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLBELTHOLD, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[236])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1009, 184}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1009}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[237] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLBREAKAWAY, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_6_4v, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[237])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[237] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLBREAKAWAY, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_6_4v, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[237])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1045, 193}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1045}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[238] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLCLOSINGMARUBOZU, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[238])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[238] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLCLOSINGMARUBOZU, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[238])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1081, 193}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1081}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[239] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLCONCEALBABYSWALL, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[239])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[239] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLCONCEALBABYSWALL, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[239])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1117, 188}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1117}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[240] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLCOUNTERATTACK, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_RvXR, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[240])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[240] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLCOUNTERATTACK, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_RvXR, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[240])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1153, 207}; + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1153}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[241] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLDARKCLOUDCOVER, __pyx_k_K_L_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[241])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[241] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLDARKCLOUDCOVER, __pyx_mstate->__pyx_kp_b_iso88591_K_L_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[241])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1191, 182}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1191}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[242] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLDOJI, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_BfHB_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[242])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[242] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLDOJI, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_BfHB_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[242])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1227, 183}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1227}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[243] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLDOJISTAR, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[243])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[243] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLDOJISTAR, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[243])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1263, 188}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1263}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[244] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLDRAGONFLYDOJI, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_RvXR, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[244])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[244] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLDRAGONFLYDOJI, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_RvXR, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[244])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1299, 184}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1299}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[245] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLENGULFING, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_6_4v, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[245])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[245] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLENGULFING, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_6_4v, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[245])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1335, 207}; + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1335}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[246] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLEVENINGDOJISTAR, __pyx_k_L_M_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[246])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[246] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLEVENINGDOJISTAR, __pyx_mstate->__pyx_kp_b_iso88591_L_M_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[246])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1373, 202}; + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1373}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[247] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLEVENINGSTAR, __pyx_k_H_I_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[247])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[247] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLEVENINGSTAR, __pyx_mstate->__pyx_kp_b_iso88591_H_I_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[247])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1411, 193}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1411}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[248] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLGAPSIDESIDEWHITE, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[248])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[248] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLGAPSIDESIDEWHITE, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[248])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1447, 193}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1447}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[249] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLGRAVESTONEDOJI, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[249])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[249] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLGRAVESTONEDOJI, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[249])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1483, 183}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1483}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[250] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHAMMER, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[250])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[250] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHAMMER, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[250])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1519, 184}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1519}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[251] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHANGINGMAN, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_F_D, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[251])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[251] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHANGINGMAN, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_F_D, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[251])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1555, 183}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1555}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[252] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHARAMI, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[252])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[252] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHARAMI, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[252])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1591, 184}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1591}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[253] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHARAMICROSS, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_2V82, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[253])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[253] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHARAMICROSS, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_2V82, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[253])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1627, 183}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1627}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[254] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHIGHWAVE, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[254])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[254] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHIGHWAVE, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[254])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1663, 183}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1663}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[255] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHIKKAKE, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[255])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[255] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHIKKAKE, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[255])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1699, 184}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1699}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[256] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHIKKAKEMOD, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_F_D, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[256])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[256] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHIKKAKEMOD, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_F_D, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[256])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1735, 184}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1735}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[257] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHOMINGPIGEON, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_BfHB, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[257])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[257] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHOMINGPIGEON, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_BfHB, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[257])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1771, 193}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1771}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[258] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLIDENTICAL3CROWS, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[258])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[258] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLIDENTICAL3CROWS, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[258])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1807, 183}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1807}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[259] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLINNECK, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[259])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[259] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLINNECK, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[259])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1843, 193}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1843}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[260] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLINVERTEDHAMMER, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[260])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[260] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLINVERTEDHAMMER, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[260])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1879, 183}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1879}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[261] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLKICKING, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[261])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[261] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLKICKING, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[261])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1915, 193}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1915}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[262] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLKICKINGBYLENGTH, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[262])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[262] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLKICKINGBYLENGTH, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[262])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1951, 184}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1951}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[263] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLLADDERBOTTOM, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_BfHB, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[263])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[263] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLLADDERBOTTOM, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_BfHB, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[263])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1987, 193}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1987}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[264] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLLONGLEGGEDDOJI, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[264])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[264] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLLONGLEGGEDDOJI, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[264])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2023, 183}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2023}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[265] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLLONGLINE, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[265])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[265] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLLONGLINE, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[265])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2059, 183}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2059}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[266] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLMARUBOZU, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[266])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[266] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLMARUBOZU, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[266])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2095, 184}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2095}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[267] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLMATCHINGLOW, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_2V82, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[267])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[267] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLMATCHINGLOW, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_2V82, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[267])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2131, 201}; + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2131}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[268] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLMATHOLD, __pyx_k_D_E_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[268])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[268] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLMATHOLD, __pyx_mstate->__pyx_kp_b_iso88591_D_E_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[268])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2169, 207}; + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2169}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[269] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLMORNINGDOJISTAR, __pyx_k_L_M_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[269])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[269] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLMORNINGDOJISTAR, __pyx_mstate->__pyx_kp_b_iso88591_L_M_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[269])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2207, 202}; + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2207}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[270] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLMORNINGSTAR, __pyx_k_H_I_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[270])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[270] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLMORNINGSTAR, __pyx_mstate->__pyx_kp_b_iso88591_H_I_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[270])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2245, 183}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2245}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[271] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLONNECK, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[271])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[271] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLONNECK, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[271])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2281, 183}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2281}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[272] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLPIERCING, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[272])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[272] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLPIERCING, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[272])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2317, 184}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2317}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[273] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLRICKSHAWMAN, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_2V82, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[273])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[273] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLRICKSHAWMAN, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_2V82, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[273])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2353, 193}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2353}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[274] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLRISEFALL3METHODS, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[274])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[274] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLRISEFALL3METHODS, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[274])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2389, 193}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2389}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[275] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLSEPARATINGLINES, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[275])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[275] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLSEPARATINGLINES, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[275])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2425, 184}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2425}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[276] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLSHOOTINGSTAR, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_BfHB, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[276])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[276] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLSHOOTINGSTAR, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_BfHB, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[276])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2461, 184}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2461}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[277] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLSHORTLINE, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_6_4v, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[277])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[277] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLSHORTLINE, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_6_4v, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[277])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2497, 184}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2497}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[278] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLSPINNINGTOP, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_2V82, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[278])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[278] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLSPINNINGTOP, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_2V82, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[278])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2533, 193}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2533}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[279] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLSTALLEDPATTERN, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[279])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[279] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLSTALLEDPATTERN, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[279])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2569, 188}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2569}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[280] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLSTICKSANDWICH, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_RvXR, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[280])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[280] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLSTICKSANDWICH, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_RvXR, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[280])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2605, 183}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2605}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[281] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLTAKURI, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[281])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[281] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLTAKURI, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[281])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2641, 184}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2641}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[282] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLTASUKIGAP, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_6_4v, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[282])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[282] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLTASUKIGAP, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_6_4v, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[282])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2677, 184}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2677}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[283] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLTHRUSTING, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_6_4v, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[283])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[283] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLTHRUSTING, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_6_4v, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[283])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2713, 183}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2713}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[284] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLTRISTAR, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[284])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[284] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLTRISTAR, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[284])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2749, 184}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2749}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[285] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLUNIQUE3RIVER, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_BfHB, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[285])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[285] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLUNIQUE3RIVER, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_BfHB, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[285])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2785, 193}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2785}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[286] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLUPSIDEGAP2CROWS, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[286])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[286] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLUPSIDEGAP2CROWS, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[286])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2821, 193}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2821}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[287] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLXSIDEGAP3METHODS, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[287])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[287] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLXSIDEGAP3METHODS, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[287])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2857, 94}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2857}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[288] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CEIL, __pyx_k_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[288])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[288] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CEIL, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[288])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2884, 100}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2884}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[289] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CMO, __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[289])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[289] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CMO, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[289])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2913, 134}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2913}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real0_data, __pyx_mstate->__pyx_n_u_real1_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[290] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CORREL, __pyx_k_KL_Kq_q_Kq_q_7_a_2V82T_xr_R__ll, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[290])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[290] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CORREL, __pyx_mstate->__pyx_kp_b_iso88591_KL_Kq_q_Kq_q_7_a_2V82T_xr_R__ll, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[290])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2946, 93}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2946}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[291] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_COS, __pyx_k_aq_Q_T_q_a_fHBd_a_kkllm_Qj_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[291])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[291] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_COS, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_fHBd_a_kkllm_Qj_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[291])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2973, 94}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2973}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[292] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_COSH, __pyx_k_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[292])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[292] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_COSH, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[292])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3000, 100}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3000}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[293] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_DEMA, __pyx_k_aq_Q_T_q_a_6_4vXRt_iijjyyzz_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[293])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[293] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_DEMA, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_6_4vXRt_iijjyyzz_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[293])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3029, 115}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3029}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real0_data, __pyx_mstate->__pyx_n_u_real1_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[294] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_DIV, __pyx_k_Kq_q_Kq_q_7_a_fHBd_iijjyyzz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[294])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[294] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_DIV, __pyx_mstate->__pyx_kp_b_iso88591_Kq_q_Kq_q_7_a_fHBd_iijjyyzz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[294])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3060, 160}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3060}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[295] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_DX, __pyx_k_a_aq_Q_Qa_y_1_Kq_q_6_a_a_r_xr_V, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[295])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[295] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_DX, __pyx_mstate->__pyx_kp_b_iso88591_a_aq_Q_Qa_y_1_Kq_q_6_a_a_r_xr_V, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[295])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3095, 100}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3095}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[296] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_EMA, __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[296])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[296] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_EMA, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[296])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3124, 93}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3124}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[297] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_EXP, __pyx_k_aq_Q_T_q_a_fHBd_a_kkllm_Qj_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[297])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[297] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_EXP, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_fHBd_a_kkllm_Qj_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[297])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3151, 95}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3151}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[298] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_FLOOR, __pyx_k_aq_Q_T_q_a_F_D_hb_LPQQ_mmnno_Ql, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[298])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[298] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_FLOOR, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_F_D_hb_LPQQ_mmnno_Ql, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[298])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3178, 96}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3178}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[299] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_HT_DCPERIOD, __pyx_k_aq_Q_T_q_a_fHBd_VWWccddssttu_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[299])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[299] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_HT_DCPERIOD, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_fHBd_VWWccddssttu_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[299])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3205, 96}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3205}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[300] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_HT_DCPHASE, __pyx_k_aq_Q_T_q_a_r_xr_V82T_UVVbbccrrs, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[300])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[300] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_HT_DCPHASE, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_r_xr_V82T_UVVbbccrrs, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[300])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3232, 117}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3232}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinphase, __pyx_mstate->__pyx_n_u_outquadrature}; - __pyx_mstate_global->__pyx_codeobj_tab[301] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_HT_PHASOR, __pyx_k_aq_Q_T_q_A_b_hb_F_D_TUUaabbqqrr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[301])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[301] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_HT_PHASOR, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_A_b_hb_F_D_TUUaabbqqrr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[301])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3262, 108}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3262}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outsine, __pyx_mstate->__pyx_n_u_outleadsine}; - __pyx_mstate_global->__pyx_codeobj_tab[302] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_HT_SINE, __pyx_k_aq_Q_T_q_a_BfHBd_lRSS___ooppzz, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[302])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[302] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_HT_SINE, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_BfHBd_lRSS___ooppzz, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[302])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3292, 97}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3292}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[303] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_HT_TRENDLINE, __pyx_k_aq_Q_T_q_a_6_4vXRt_WXXddeettuuv, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[303])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[303] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_HT_TRENDLINE, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_6_4vXRt_WXXddeettuuv, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[303])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3319, 97}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3319}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[304] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_HT_TRENDMODE, __pyx_k_aq_Q_T_q_6_4vXRt_WXXddeettuuv_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[304])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[304] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_HT_TRENDMODE, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_6_4vXRt_WXXddeettuuv_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[304])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3346, 133}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3346}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[305] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_IMI, __pyx_k_GH_aq_Q_Kq_q_6_a_fHBd_m_hhiiuuv, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[305])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[305] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_IMI, __pyx_mstate->__pyx_kp_b_iso88591_GH_aq_Q_Kq_q_6_a_fHBd_m_hhiiuuv, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[305])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3378, 100}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3378}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[306] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_KAMA, __pyx_k_aq_Q_T_q_a_6_4vXRt_iijjyyzz_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[306])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[306] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_KAMA, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_6_4vXRt_iijjyyzz_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[306])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3407, 106}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3407}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[307] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_LINEARREG, __pyx_k_12_aq_Q_T_q_a_b_hb_F_D_Taabbnno, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[307])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[307] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_LINEARREG, __pyx_mstate->__pyx_kp_b_iso88591_12_aq_Q_T_q_a_b_hb_F_D_Taabbnno, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[307])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3436, 115}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3436}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[308] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_LINEARREG_ANGLE, __pyx_k_78_aq_Q_T_q_a_BfHBd_lZgghhttu_v, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[308])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[308] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_LINEARREG_ANGLE, __pyx_mstate->__pyx_kp_b_iso88591_78_aq_Q_T_q_a_BfHBd_lZgghhttu_v, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[308])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3465, 116}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3465}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[309] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_LINEARREG_INTERCEPT, __pyx_k_aq_Q_T_q_a_fHBdR_kkllxxy_z_I_I, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[309])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[309] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_LINEARREG_INTERCEPT, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_fHBdR_kkllxxy_z_I_I, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[309])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3494, 115}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3494}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[310] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_LINEARREG_SLOPE, __pyx_k_78_aq_Q_T_q_a_BfHBd_lZgghhttu_v, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[310])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[310] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_LINEARREG_SLOPE, __pyx_mstate->__pyx_kp_b_iso88591_78_aq_Q_T_q_a_BfHBd_lZgghhttu_v, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[310])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3523, 93}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3523}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[311] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_LN, __pyx_k_aq_Q_T_q_a_r_xr_V82T_QlZ_jjkkl, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[311])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[311] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_LN, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_r_xr_V82T_QlZ_jjkkl, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[311])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3550, 95}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3550}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[312] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_LOG10, __pyx_k_aq_Q_T_q_a_F_D_hb_LPQQ_mmnno_Ql, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[312])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[312] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_LOG10, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_F_D_hb_LPQQ_mmnno_Ql, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[312])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3577, 117}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3577}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[313] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MA, __pyx_k_B_aq_Q_T_q_a_r_xr_V82T_Zccddppq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[313])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[313] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MA, __pyx_mstate->__pyx_kp_b_iso88591_B_aq_Q_T_q_a_r_xr_V82T_Zccddppq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[313])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3607, 175}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3607}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_fastperiod, __pyx_mstate->__pyx_n_u_slowperiod, __pyx_mstate->__pyx_n_u_signalperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outmacd, __pyx_mstate->__pyx_n_u_outmacdsignal, __pyx_mstate->__pyx_n_u_outmacdhist}; - __pyx_mstate_global->__pyx_codeobj_tab[314] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MACD, __pyx_k_DD_2_aq_Q_T_q_a_A_6_4vXRt_iixxy, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[314])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[314] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MACD, __pyx_mstate->__pyx_kp_b_iso88591_DD_2_aq_Q_T_q_a_A_6_4vXRt_iixxy, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[314])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {7, 0, 0, 15, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3644, 222}; + const __Pyx_PyCode_New_function_description descr = {7, 0, 0, 15, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3644}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_fastperiod, __pyx_mstate->__pyx_n_u_fastmatype, __pyx_mstate->__pyx_n_u_slowperiod, __pyx_mstate->__pyx_n_u_slowmatype, __pyx_mstate->__pyx_n_u_signalperiod, __pyx_mstate->__pyx_n_u_signalmatype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outmacd, __pyx_mstate->__pyx_n_u_outmacdsignal, __pyx_mstate->__pyx_n_u_outmacdhist}; - __pyx_mstate_global->__pyx_codeobj_tab[315] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MACDEXT, __pyx_k_GGZZr_s_F_F_a_8_aq_Q_T_q_a_A_Bf, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[315])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[315] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MACDEXT, __pyx_mstate->__pyx_kp_b_iso88591_GGZZr_s_F_F_a_8_aq_Q_T_q_a_A_Bf, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[315])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3684, 148}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3684}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_signalperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outmacd, __pyx_mstate->__pyx_n_u_outmacdsignal, __pyx_mstate->__pyx_n_u_outmacdhist}; - __pyx_mstate_global->__pyx_codeobj_tab[316] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MACDFIX, __pyx_k_0_aq_Q_T_q_a_A_BfHBd_lRaabbnnoo, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[316])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[316] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MACDFIX, __pyx_mstate->__pyx_kp_b_iso88591_0_aq_Q_T_q_a_A_BfHBd_lRaabbnnoo, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[316])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3719, 138}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3719}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_fastlimit, __pyx_mstate->__pyx_n_u_slowlimit, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outmama, __pyx_mstate->__pyx_n_u_outfama}; - __pyx_mstate_global->__pyx_codeobj_tab[317] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MAMA, __pyx_k_EQ_aq_Q_T_q_a_a_6_4vXRt_gghhttu, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[317])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[317] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MAMA, __pyx_mstate->__pyx_kp_b_iso88591_EQ_aq_Q_T_q_a_a_6_4vXRt_gghhttu, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[317])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3752, 157}; + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3752}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_periods, __pyx_mstate->__pyx_n_u_minperiod, __pyx_mstate->__pyx_n_u_maxperiod, __pyx_mstate->__pyx_n_u_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_periods_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[318] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MAVP, __pyx_k_Jaaxxy_aq_Q_k_9G1_6_a_6_4vXRt_j, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[318])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[318] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MAVP, __pyx_mstate->__pyx_kp_b_iso88591_Jaaxxy_aq_Q_k_9G1_6_a_6_4vXRt_j, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[318])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3787, 100}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3787}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[319] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MAX, __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[319])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[319] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MAX, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[319])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3816, 101}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3816}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[320] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MAXINDEX, __pyx_k_01_aq_Q_T_q_RvXRt6_4_S_aammnn_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[320])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[320] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MAXINDEX, __pyx_mstate->__pyx_kp_b_iso88591_01_aq_Q_T_q_RvXRt6_4_S_aammnn_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[320])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3845, 116}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3845}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[321] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MEDPRICE, __pyx_k_aq_Q_Qa_y_1_6_a_RvXRt6_4_S___kk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[321])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[321] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MEDPRICE, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_Qa_y_1_6_a_RvXRt6_4_S___kk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[321])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3875, 195}; + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3875}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_volume, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_volume_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[322] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MFI, __pyx_k_aq_Q_Qa_y_1_Kq_q_6_6_gQ_a_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[322])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[322] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MFI, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_Qa_y_1_Kq_q_6_6_gQ_a_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[322])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3913, 101}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3913}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[323] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MIDPOINT, __pyx_k_01_aq_Q_T_q_a_RvXRt6_4_S_aammnn, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[323])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[323] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MIDPOINT, __pyx_mstate->__pyx_kp_b_iso88591_01_aq_Q_T_q_a_RvXRt6_4_S_aammnn, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[323])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3942, 134}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3942}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[324] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MIDPRICE, __pyx_k_JK_aq_Q_Qa_y_1_6_a_RvXRt6_4_S_k, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[324])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[324] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MIDPRICE, __pyx_mstate->__pyx_kp_b_iso88591_JK_aq_Q_Qa_y_1_6_a_RvXRt6_4_S_k, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[324])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3974, 100}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3974}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[325] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MIN, __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[325])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[325] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MIN, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[325])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4003, 101}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4003}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger}; - __pyx_mstate_global->__pyx_codeobj_tab[326] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MININDEX, __pyx_k_01_aq_Q_T_q_RvXRt6_4_S_aammnn_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[326])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[326] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MININDEX, __pyx_mstate->__pyx_kp_b_iso88591_01_aq_Q_T_q_RvXRt6_4_S_aammnn_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[326])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4032, 126}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4032}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outmin, __pyx_mstate->__pyx_n_u_outmax}; - __pyx_mstate_global->__pyx_codeobj_tab[327] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MINMAX, __pyx_k_aq_Q_T_q_Q_Q_2V82T_xr_Q___kkll, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[327])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[327] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MINMAX, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_Q_Q_2V82T_xr_Q___kkll, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[327])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4064, 135}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4064}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outminidx, __pyx_mstate->__pyx_n_u_outmaxidx}; - __pyx_mstate_global->__pyx_codeobj_tab[328] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MINMAXINDEX, __pyx_k_34_aq_Q_T_q_fHBd_Vccddppq_r_A_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[328])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[328] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MINMAXINDEX, __pyx_mstate->__pyx_kp_b_iso88591_34_aq_Q_T_q_fHBd_Vccddppq_r_A_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[328])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4096, 165}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4096}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[329] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MINUS_DI, __pyx_k_fg_aq_Q_Qa_y_1_Kq_q_6_a_a_RvXRt, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[329])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[329] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MINUS_DI, __pyx_mstate->__pyx_kp_b_iso88591_fg_aq_Q_Qa_y_1_Kq_q_6_a_a_RvXRt, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[329])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4131, 134}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4131}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[330] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MINUS_DM, __pyx_k_JK_aq_Q_Qa_y_1_6_a_RvXRt6_4_S_k, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[330])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[330] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MINUS_DM, __pyx_mstate->__pyx_kp_b_iso88591_JK_aq_Q_Qa_y_1_6_a_RvXRt6_4_S_k, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[330])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4163, 100}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4163}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[331] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MOM, __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[331])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[331] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MOM, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[331])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4192, 116}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4192}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real0_data, __pyx_mstate->__pyx_n_u_real1_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[332] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MULT, __pyx_k_Kq_q_Kq_q_7_a_6_4vXRt_P_jjkkzz, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[332])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[332] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MULT, __pyx_mstate->__pyx_kp_b_iso88591_Kq_q_Kq_q_7_a_6_4vXRt_P_jjkkzz, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[332])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4223, 164}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4223}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[333] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_NATR, __pyx_k_bc_aq_Q_Qa_y_1_Kq_q_6_a_a_6_4vX, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[333])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[333] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_NATR, __pyx_mstate->__pyx_kp_b_iso88591_bc_aq_Q_Qa_y_1_Kq_q_6_a_a_6_4vX, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[333])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4258, 115}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4258}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_volume, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_volume_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[334] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_OBV, __pyx_k_aq_Q_6_6_a_fHBd_n_iijjyyzz_Qj_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[334])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[334] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_OBV, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_6_6_a_fHBd_n_iijjyyzz_Qj_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[334])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4289, 165}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4289}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[335] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_PLUS_DI, __pyx_k_ef_aq_Q_Qa_y_1_Kq_q_6_a_a_BfHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[335])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[335] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_PLUS_DI, __pyx_mstate->__pyx_kp_b_iso88591_ef_aq_Q_Qa_y_1_Kq_q_6_a_a_BfHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[335])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4324, 134}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4324}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[336] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_PLUS_DM, __pyx_k_IJ_aq_Q_Qa_y_1_6_a_BfHBd_lR_jjk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[336])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[336] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_PLUS_DM, __pyx_mstate->__pyx_kp_b_iso88591_IJ_aq_Q_Qa_y_1_6_a_BfHBd_lR_jjk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[336])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4356, 124}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4356}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_fastperiod, __pyx_mstate->__pyx_n_u_slowperiod, __pyx_mstate->__pyx_n_u_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[337] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_PPO, __pyx_k_CC_aq_Q_T_q_a_fHBd_m_hhqqrr_O_O, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[337])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[337] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_PPO, __pyx_mstate->__pyx_kp_b_iso88591_CC_aq_Q_T_q_a_fHBd_m_hhqqrr_O_O, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[337])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4387, 100}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4387}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[338] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ROC, __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[338])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[338] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ROC, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[338])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4416, 100}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4416}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[339] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ROCP, __pyx_k_aq_Q_T_q_a_6_4vXRt_iijjyyzz_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[339])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[339] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ROCP, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_6_4vXRt_iijjyyzz_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[339])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4445, 100}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4445}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[340] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ROCR, __pyx_k_aq_Q_T_q_a_6_4vXRt_iijjyyzz_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[340])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[340] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ROCR, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_6_4vXRt_iijjyyzz_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[340])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4474, 101}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4474}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[341] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ROCR100, __pyx_k_0_aq_Q_T_q_a_BfHBd_lR___llmm_Qn, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[341])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[341] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ROCR100, __pyx_mstate->__pyx_kp_b_iso88591_0_aq_Q_T_q_a_BfHBd_lR___llmm_Qn, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[341])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4503, 100}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4503}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[342] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_RSI, __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[342])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[342] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_RSI, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[342])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4532, 143}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4532}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_acceleration, __pyx_mstate->__pyx_n_u_maximum, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[343] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SAR, __pyx_k_E_a_aq_Q_Qa_y_1_6_a_fHBd_kYhhrr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[343])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[343] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SAR, __pyx_mstate->__pyx_kp_b_iso88591_E_a_aq_Q_Qa_y_1_6_a_fHBd_kYhhrr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[343])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {10, 0, 0, 17, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4565, 240}; + const __Pyx_PyCode_New_function_description descr = {10, 0, 0, 17, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4565}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_startvalue, __pyx_mstate->__pyx_n_u_offsetonreverse, __pyx_mstate->__pyx_n_u_accelerationinitlong, __pyx_mstate->__pyx_n_u_accelerationlong, __pyx_mstate->__pyx_n_u_accelerationmaxlong, __pyx_mstate->__pyx_n_u_accelerationinitshort, __pyx_mstate->__pyx_n_u_accelerationshort, __pyx_mstate->__pyx_n_u_accelerationmaxshort, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[344] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SAREXT, __pyx_k_Hb_c_B_B_f_f_F_F_i_i_N_N_o_o_p, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[344])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[344] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SAREXT, __pyx_mstate->__pyx_kp_b_iso88591_Hb_c_B_B_f_f_F_F_i_i_N_N_o_o_p, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[344])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4604, 93}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4604}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[345] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SIN, __pyx_k_aq_Q_T_q_a_fHBd_a_kkllm_Qj_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[345])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[345] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SIN, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_fHBd_a_kkllm_Qj_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[345])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4631, 94}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4631}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[346] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SINH, __pyx_k_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[346])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[346] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SINH, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[346])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4658, 100}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4658}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[347] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SMA, __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[347])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[347] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SMA, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[347])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4687, 94}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4687}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[348] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SQRT, __pyx_k_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[348])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[348] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SQRT, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[348])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4714, 118}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4714}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_nbdev, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[349] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_STDDEV, __pyx_k_Fa_aq_Q_T_q_a_2V82T_xr_Q_ffggss, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[349])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[349] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_STDDEV, __pyx_mstate->__pyx_kp_b_iso88591_Fa_aq_Q_T_q_a_2V82T_xr_Q_ffggss, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[349])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {8, 0, 0, 17, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4744, 246}; + const __Pyx_PyCode_New_function_description descr = {8, 0, 0, 17, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4744}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_fastk_period, __pyx_mstate->__pyx_n_u_slowk_period, __pyx_mstate->__pyx_n_u_slowk_matype, __pyx_mstate->__pyx_n_u_slowd_period, __pyx_mstate->__pyx_n_u_slowd_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outslowk, __pyx_mstate->__pyx_n_u_outslowd}; - __pyx_mstate_global->__pyx_codeobj_tab[350] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_STOCH, __pyx_k_c_X_X_m_m_G_G_H_6_aq_Q_Qa_y_1_K, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[350])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[350] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_STOCH, __pyx_mstate->__pyx_kp_b_iso88591_c_X_X_m_m_G_G_H_6_aq_Q_Qa_y_1_K, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[350])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {6, 0, 0, 15, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4786, 218}; + const __Pyx_PyCode_New_function_description descr = {6, 0, 0, 15, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4786}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_fastk_period, __pyx_mstate->__pyx_n_u_fastd_period, __pyx_mstate->__pyx_n_u_fastd_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outfastk, __pyx_mstate->__pyx_n_u_outfastd}; - __pyx_mstate_global->__pyx_codeobj_tab[351] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_STOCHF, __pyx_k_d_Y_Y_Z_2_aq_Q_Qa_y_1_Kq_q_6_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[351])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[351] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_STOCHF, __pyx_mstate->__pyx_kp_b_iso88591_d_Y_Y_Z_2_aq_Q_Qa_y_1_Kq_q_6_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[351])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4826, 168}; + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4826}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_fastk_period, __pyx_mstate->__pyx_n_u_fastd_period, __pyx_mstate->__pyx_n_u_fastd_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outfastk, __pyx_mstate->__pyx_n_u_outfastd}; - __pyx_mstate_global->__pyx_codeobj_tab[352] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_STOCHRSI, __pyx_k_0HHbb_0_aq_Q_T_q_q_q_RvXRt6_4_S, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[352])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[352] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_STOCHRSI, __pyx_mstate->__pyx_kp_b_iso88591_0HHbb_0_aq_Q_T_q_q_q_RvXRt6_4_S, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[352])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4861, 115}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4861}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real0_data, __pyx_mstate->__pyx_n_u_real1_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[353] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SUB, __pyx_k_Kq_q_Kq_q_7_a_fHBd_iijjyyzz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[353])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[353] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SUB, __pyx_mstate->__pyx_kp_b_iso88591_Kq_q_Kq_q_7_a_fHBd_iijjyyzz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[353])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4892, 100}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4892}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[354] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SUM, __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[354])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[354] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SUM, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[354])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4921, 117}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4921}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_vfactor, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[355] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_T3, __pyx_k_B_aq_Q_T_q_a_r_xr_V82T_Zddeeqqr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[355])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[355] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_T3, __pyx_mstate->__pyx_kp_b_iso88591_B_aq_Q_T_q_a_r_xr_V82T_Zddeeqqr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[355])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4951, 93}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4951}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[356] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TAN, __pyx_k_aq_Q_T_q_a_fHBd_a_kkllm_Qj_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[356])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[356] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TAN, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_fHBd_a_kkllm_Qj_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[356])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4978, 94}; + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4978}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[357] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TANH, __pyx_k_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[357])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[357] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TANH, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[357])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5005, 100}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5005}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[358] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TEMA, __pyx_k_aq_Q_T_q_a_6_4vXRt_iijjyyzz_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[358])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[358] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TEMA, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_6_4vXRt_iijjyyzz_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[358])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5034, 151}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5034}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[359] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TRANGE, __pyx_k_aq_Q_Qa_y_1_Kq_q_6_a_a_2V82T_xr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[359])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[359] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TRANGE, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_Qa_y_1_Kq_q_6_a_a_2V82T_xr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[359])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5067, 101}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5067}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[360] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TRIMA, __pyx_k_aq_Q_T_q_a_F_D_hb_LP_jjkkzz_Ql, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[360])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[360] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TRIMA, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_F_D_hb_LP_jjkkzz_Ql, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[360])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5096, 100}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5096}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[361] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TRIX, __pyx_k_aq_Q_T_q_a_6_4vXRt_iijjyyzz_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[361])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[361] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TRIX, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_6_4vXRt_iijjyyzz_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[361])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5125, 100}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5125}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[362] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TSF, __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[362])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[362] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TSF, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[362])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5154, 151}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5154}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[363] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TYPPRICE, __pyx_k_aq_Q_Qa_y_1_Kq_q_6_a_a_RvXRt6_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[363])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[363] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TYPPRICE, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_Qa_y_1_Kq_q_6_a_a_RvXRt6_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[363])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {6, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5187, 197}; + const __Pyx_PyCode_New_function_description descr = {6, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5187}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod1, __pyx_mstate->__pyx_n_u_timeperiod2, __pyx_mstate->__pyx_n_u_timeperiod3, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[364] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ULTOSC, __pyx_k_d_W_W_X_aq_Q_Qa_y_1_Kq_q_6_a_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[364])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[364] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ULTOSC, __pyx_mstate->__pyx_kp_b_iso88591_d_W_W_X_aq_Q_Qa_y_1_Kq_q_6_a_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[364])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5224, 117}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5224}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_nbdev, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[365] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_VAR, __pyx_k_C1_aq_Q_T_q_a_fHBd_m_ccddppq_r, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[365])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[365] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_VAR, __pyx_mstate->__pyx_kp_b_iso88591_C1_aq_Q_T_q_a_fHBd_m_ccddppq_r, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[365])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5254, 151}; + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5254}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[366] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_WCLPRICE, __pyx_k_aq_Q_Qa_y_1_Kq_q_6_a_a_RvXRt6_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[366])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[366] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_WCLPRICE, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_Qa_y_1_Kq_q_6_a_a_RvXRt6_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[366])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5287, 165}; + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5287}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[367] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_WILLR, __pyx_k_cd_aq_Q_Qa_y_1_Kq_q_6_a_a_F_D_h, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[367])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[367] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_WILLR, __pyx_mstate->__pyx_kp_b_iso88591_cd_aq_Q_Qa_y_1_Kq_q_6_a_a_F_D_h, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[367])) goto bad; } { - const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5322, 100}; + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5322}; PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal}; - __pyx_mstate_global->__pyx_codeobj_tab[368] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_WMA, __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[368])) goto bad; + __pyx_mstate_global->__pyx_codeobj_tab[368] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_WMA, __pyx_mstate->__pyx_kp_b_iso88591_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[368])) goto bad; } Py_DECREF(tuple_dedup_map); return 0; @@ -89873,22 +89015,32 @@ static int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate) { static int __Pyx_InitGlobals(void) { /* PythonCompatibility.init */ if (likely(__Pyx_init_co_variables() == 0)); else + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) -if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + /* CommonTypesMetaclass.init */ + if (likely(__pyx_CommonTypesMetaclass_init(__pyx_m) == 0)); else + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) /* CachedMethodType.init */ #if CYTHON_COMPILING_IN_LIMITED_API -{ - PyObject *typesModule=NULL; - typesModule = PyImport_ImportModule("types"); - if (typesModule) { - __pyx_mstate_global->__Pyx_CachedMethodType = PyObject_GetAttrString(typesModule, "MethodType"); - Py_DECREF(typesModule); - } -} // error handling follows -#endif + { + PyObject *typesModule=NULL; + typesModule = PyImport_ImportModule("types"); + if (typesModule) { + __pyx_mstate_global->__Pyx_CachedMethodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + } + } // error handling follows + #endif + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) -if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + /* CythonFunctionShared.init */ + if (likely(__pyx_CyFunction_init(__pyx_m) == 0)); else + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) return 0; __pyx_L1_error:; @@ -89929,7 +89081,7 @@ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { } #endif -/* PyErrExceptionMatches */ +/* PyErrExceptionMatches (used by PyObjectGetAttrStrNoError) */ #if CYTHON_FAST_THREAD_STATE static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; @@ -89970,7 +89122,7 @@ static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tsta } #endif -/* PyErrFetchRestore */ +/* PyErrFetchRestore (used by PyObjectGetAttrStrNoError) */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { #if PY_VERSION_HEX >= 0x030C00A6 @@ -90029,7 +89181,7 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject } #endif -/* PyObjectGetAttrStr */ +/* PyObjectGetAttrStr (used by PyObjectGetAttrStrNoError) */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); @@ -90039,7 +89191,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject } #endif -/* PyObjectGetAttrStrNoError */ +/* PyObjectGetAttrStrNoError (used by GetBuiltinName) */ #if __PYX_LIMITED_VERSION_HEX < 0x030d0000 static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { __Pyx_PyThreadState_declare @@ -90078,7 +89230,7 @@ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { return result; } -/* GetTopmostException */ +/* GetTopmostException (used by SaveResetException) */ #if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) @@ -90263,111 +89415,7 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif } -/* PyFunctionFastCall */ -#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL -static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject *const *args, Py_ssize_t na, - PyObject *globals) { - PyFrameObject *f; - PyThreadState *tstate = __Pyx_PyThreadState_Current; - PyObject **fastlocals; - Py_ssize_t i; - PyObject *result; - assert(globals != NULL); - /* XXX Perhaps we should create a specialized - PyFrame_New() that doesn't take locals, but does - take builtins without sanity checking them. - */ - assert(tstate != NULL); - f = PyFrame_New(tstate, co, globals, NULL); - if (f == NULL) { - return NULL; - } - fastlocals = __Pyx_PyFrame_GetLocalsplus(f); - for (i = 0; i < na; i++) { - Py_INCREF(*args); - fastlocals[i] = *args++; - } - result = PyEval_EvalFrameEx(f,0); - ++tstate->recursion_depth; - Py_DECREF(f); - --tstate->recursion_depth; - return result; -} -static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject *const *args, Py_ssize_t nargs, PyObject *kwargs) { - PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); - PyObject *globals = PyFunction_GET_GLOBALS(func); - PyObject *argdefs = PyFunction_GET_DEFAULTS(func); - PyObject *closure; - PyObject *kwdefs; - PyObject *kwtuple, **k; - PyObject **d; - Py_ssize_t nd; - Py_ssize_t nk; - PyObject *result; - assert(kwargs == NULL || PyDict_Check(kwargs)); - nk = kwargs ? PyDict_Size(kwargs) : 0; - if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { - return NULL; - } - if ( - co->co_kwonlyargcount == 0 && - likely(kwargs == NULL || nk == 0) && - co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { - if (argdefs == NULL && co->co_argcount == nargs) { - result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); - goto done; - } - else if (nargs == 0 && argdefs != NULL - && co->co_argcount == Py_SIZE(argdefs)) { - /* function called with no arguments, but all parameters have - a default value: use default values as arguments .*/ - args = &PyTuple_GET_ITEM(argdefs, 0); - result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); - goto done; - } - } - if (kwargs != NULL) { - Py_ssize_t pos, i; - kwtuple = PyTuple_New(2 * nk); - if (kwtuple == NULL) { - result = NULL; - goto done; - } - k = &PyTuple_GET_ITEM(kwtuple, 0); - pos = i = 0; - while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { - Py_INCREF(k[i]); - Py_INCREF(k[i+1]); - i += 2; - } - nk = i / 2; - } - else { - kwtuple = NULL; - k = NULL; - } - closure = PyFunction_GET_CLOSURE(func); - kwdefs = PyFunction_GET_KW_DEFAULTS(func); - if (argdefs != NULL) { - d = &PyTuple_GET_ITEM(argdefs, 0); - nd = Py_SIZE(argdefs); - } - else { - d = NULL; - nd = 0; - } - result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, kwdefs, closure); - Py_XDECREF(kwtuple); -done: - Py_LeaveRecursiveCall(); - return result; -} -#endif - -/* PyObjectCall */ +/* PyObjectCall (used by PyObjectFastCall) */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; @@ -90387,7 +89435,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg } #endif -/* PyObjectCallMethO */ +/* PyObjectCallMethO (used by PyObjectFastCall) */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; @@ -90462,38 +89510,16 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObj return __Pyx_PyObject_CallMethO(func, args[0]); } #endif - #if PY_VERSION_HEX < 0x030800B1 - #if CYTHON_FAST_PYCCALL - if (PyCFunction_Check(func)) { - if (kwargs) { - return _PyCFunction_FastCallDict(func, args, nargs, kwargs); - } else { - return _PyCFunction_FastCallKeywords(func, args, nargs, NULL); - } - } - if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { - return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); - } - #endif - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); - } - #endif - #endif if (kwargs == NULL) { - #if CYTHON_VECTORCALL && !CYTHON_COMPILING_IN_LIMITED_API - vectorcallfunc f = __Pyx_PyVectorcall_Function(func); - if (f) { - return f(func, args, _nargs, NULL); - } - #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL - if (__Pyx_CyFunction_CheckExact(func)) { - __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func); - if (f) return f(func, args, _nargs, NULL); - } - #elif CYTHON_COMPILING_IN_LIMITED_API && CYTHON_VECTORCALL - return PyObject_Vectorcall(func, args, _nargs, NULL); + #if CYTHON_VECTORCALL + #if CYTHON_COMPILING_IN_LIMITED_API + return PyObject_Vectorcall(func, args, _nargs, NULL); + #else + vectorcallfunc f = __Pyx_PyVectorcall_Function(func); + if (f) { + return f(func, args, _nargs, NULL); + } + #endif #endif } if (nargs == 0) { @@ -90621,18 +89647,248 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_Unicode(PyObject *obj) { return __Pyx_NewRef(obj); } -/* PyObjectFormatAndDecref */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f) { - if (unlikely(!s)) return NULL; - if (likely(PyUnicode_CheckExact(s))) return s; - return __Pyx_PyObject_FormatAndDecref(s, f); +/* CIntToDigits (used by CIntToPyUnicode) */ +static const char DIGIT_PAIRS_10[2*10*10+1] = { + "00010203040506070809" + "10111213141516171819" + "20212223242526272829" + "30313233343536373839" + "40414243444546474849" + "50515253545556575859" + "60616263646566676869" + "70717273747576777879" + "80818283848586878889" + "90919293949596979899" +}; +static const char DIGIT_PAIRS_8[2*8*8+1] = { + "0001020304050607" + "1011121314151617" + "2021222324252627" + "3031323334353637" + "4041424344454647" + "5051525354555657" + "6061626364656667" + "7071727374757677" +}; +static const char DIGITS_HEX[2*16+1] = { + "0123456789abcdef" + "0123456789ABCDEF" +}; + +/* BuildPyUnicode (used by COrdinalToPyUnicode) */ +static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, const char* chars, int clength, + int prepend_sign, char padding_char) { + PyObject *uval; + Py_ssize_t uoffset = ulength - clength; +#if CYTHON_USE_UNICODE_INTERNALS + Py_ssize_t i; + void *udata; + uval = PyUnicode_New(ulength, 127); + if (unlikely(!uval)) return NULL; + udata = PyUnicode_DATA(uval); + if (uoffset > 0) { + i = 0; + if (prepend_sign) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, 0, '-'); + i++; + } + for (; i < uoffset; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, i, padding_char); + } + } + for (i=0; i < clength; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, uoffset+i, chars[i]); + } +#else + { + PyObject *sign = NULL, *padding = NULL; + uval = NULL; + if (uoffset > 0) { + prepend_sign = !!prepend_sign; + if (uoffset > prepend_sign) { + padding = PyUnicode_FromOrdinal(padding_char); + if (likely(padding) && uoffset > prepend_sign + 1) { + PyObject *tmp = PySequence_Repeat(padding, uoffset - prepend_sign); + Py_DECREF(padding); + padding = tmp; + } + if (unlikely(!padding)) goto done_or_error; + } + if (prepend_sign) { + sign = PyUnicode_FromOrdinal('-'); + if (unlikely(!sign)) goto done_or_error; + } + } + uval = PyUnicode_DecodeASCII(chars, clength, NULL); + if (likely(uval) && padding) { + PyObject *tmp = PyUnicode_Concat(padding, uval); + Py_DECREF(uval); + uval = tmp; + } + if (likely(uval) && sign) { + PyObject *tmp = PyUnicode_Concat(sign, uval); + Py_DECREF(uval); + uval = tmp; + } +done_or_error: + Py_XDECREF(padding); + Py_XDECREF(sign); + } +#endif + return uval; } -static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f) { - PyObject *result; - if (unlikely(!s)) return NULL; - result = PyObject_Format(s, f); - Py_DECREF(s); - return result; + +/* COrdinalToPyUnicode (used by CIntToPyUnicode) */ +static CYTHON_INLINE int __Pyx_CheckUnicodeValue(int value) { + return value <= 1114111; +} +static PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t ulength, char padding_char) { + Py_ssize_t padding_length = ulength - 1; + if (likely((padding_length <= 250) && (value < 0xD800 || value > 0xDFFF))) { + char chars[256]; + if (value <= 255) { + memset(chars, padding_char, (size_t) padding_length); + chars[ulength-1] = (char) value; + return PyUnicode_DecodeLatin1(chars, ulength, NULL); + } + char *cpos = chars + sizeof(chars); + if (value < 0x800) { + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0xc0 | (value & 0x1f)); + } else if (value < 0x10000) { + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0xe0 | (value & 0x0f)); + } else { + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0xf0 | (value & 0x07)); + } + cpos -= padding_length; + memset(cpos, padding_char, (size_t) padding_length); + return PyUnicode_DecodeUTF8(cpos, chars + sizeof(chars) - cpos, NULL); + } + if (value <= 127 && CYTHON_USE_UNICODE_INTERNALS) { + const char chars[1] = {(char) value}; + return __Pyx_PyUnicode_BuildFromAscii(ulength, chars, 1, 0, padding_char); + } + { + PyObject *uchar, *padding_uchar, *padding, *result; + padding_uchar = PyUnicode_FromOrdinal(padding_char); + if (unlikely(!padding_uchar)) return NULL; + padding = PySequence_Repeat(padding_uchar, padding_length); + Py_DECREF(padding_uchar); + if (unlikely(!padding)) return NULL; + uchar = PyUnicode_FromOrdinal(value); + if (unlikely(!uchar)) { + Py_DECREF(padding); + return NULL; + } + result = PyUnicode_Concat(padding, uchar); + Py_DECREF(padding); + Py_DECREF(uchar); + return result; + } +} + +/* CIntToPyUnicode */ +static CYTHON_INLINE PyObject* __Pyx_uchar___Pyx_PyUnicode_From_TA_RetCode(TA_RetCode value, Py_ssize_t width, char padding_char) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const TA_RetCode neg_one = (TA_RetCode) -1, const_zero = (TA_RetCode) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!(is_unsigned || value == 0 || value > 0) || + !(sizeof(value) <= 2 || value & ~ (TA_RetCode) 0x01fffff || __Pyx_CheckUnicodeValue((int) value)))) { + PyErr_SetString(PyExc_OverflowError, "%c arg not in range(0x110000)"); + return NULL; + } + if (width <= 1) { + return PyUnicode_FromOrdinal((int) value); + } + return __Pyx_PyUnicode_FromOrdinal_Padded((int) value, width, padding_char); +} +static CYTHON_INLINE PyObject* __Pyx____Pyx_PyUnicode_From_TA_RetCode(TA_RetCode value, Py_ssize_t width, char padding_char, char format_char) { + char digits[sizeof(TA_RetCode)*3+2]; + char *dpos, *end = digits + sizeof(TA_RetCode)*3+2; + const char *hex_digits = DIGITS_HEX; + Py_ssize_t length, ulength; + int prepend_sign, last_one_off; + TA_RetCode remaining; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const TA_RetCode neg_one = (TA_RetCode) -1, const_zero = (TA_RetCode) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (format_char == 'X') { + hex_digits += 16; + format_char = 'x'; + } + remaining = value; + last_one_off = 0; + dpos = end; + do { + int digit_pos; + switch (format_char) { + case 'o': + digit_pos = abs((int)(remaining % (8*8))); + remaining = (TA_RetCode) (remaining / (8*8)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); + last_one_off = (digit_pos < 8); + break; + case 'd': + digit_pos = abs((int)(remaining % (10*10))); + remaining = (TA_RetCode) (remaining / (10*10)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); + last_one_off = (digit_pos < 10); + break; + case 'x': + *(--dpos) = hex_digits[abs((int)(remaining % 16))]; + remaining = (TA_RetCode) (remaining / 16); + break; + default: + assert(0); + break; + } + } while (unlikely(remaining != 0)); + assert(!last_one_off || *dpos == '0'); + dpos += last_one_off; + length = end - dpos; + ulength = length; + prepend_sign = 0; + if (!is_unsigned && value <= neg_one) { + if (padding_char == ' ' || width <= length + 1) { + *(--dpos) = '-'; + ++length; + } else { + prepend_sign = 1; + } + ++ulength; + } + if (width > ulength) { + ulength = width; + } + if (ulength == 1) { + return PyUnicode_FromOrdinal(*dpos); + } + return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); } /* JoinPyUnicode */ @@ -90703,8 +89959,8 @@ static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, CYTHON_UNUSED_VAR(max_char); CYTHON_UNUSED_VAR(result_ulength); for (i=0; i__pyx_empty_unicode, value_tuple); bad: @@ -90713,7 +89969,7 @@ static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, #endif } -/* TupleAndListFromArray */ +/* TupleAndListFromArray (used by fastcall) */ #if !CYTHON_COMPILING_IN_CPYTHON && CYTHON_METH_FASTCALL static CYTHON_INLINE PyObject * __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) @@ -90726,11 +89982,11 @@ __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) res = PyTuple_New(n); if (unlikely(res == NULL)) return NULL; for (i = 0; i < n; i++) { - if (unlikely(__Pyx_PyTuple_SET_ITEM(res, i, src[i]) < 0)) { + Py_INCREF(src[i]); + if (unlikely(__Pyx_PyTuple_SET_ITEM(res, i, src[i]) < (0))) { Py_DECREF(res); return NULL; } - Py_INCREF(src[i]); } return res; } @@ -90769,7 +90025,7 @@ __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) } #endif -/* BytesEquals */ +/* BytesEquals (used by UnicodeEquals) */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL ||\ !(CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) @@ -90817,7 +90073,7 @@ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int eq #endif } -/* UnicodeEquals */ +/* UnicodeEquals (used by fastcall) */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL return PyObject_RichCompareBool(s1, s2, equals); @@ -90952,16 +90208,13 @@ CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, Py #endif #endif -/* RaiseDoubleKeywords */ -static void __Pyx_RaiseDoubleKeywordsError( - const char* func_name, - PyObject* kw_name) -{ - PyErr_Format(PyExc_TypeError, - "%s() got multiple values for keyword argument '%U'", func_name, kw_name); +/* PyObjectCallOneArg (used by CallUnboundCMethod0) */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *args[2] = {NULL, arg}; + return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } -/* UnpackUnboundCMethod */ +/* UnpackUnboundCMethod (used by CallUnboundCMethod0) */ #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000 static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *args, PyObject *kwargs) { PyObject *result; @@ -91046,6 +90299,121 @@ static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) { return 0; } +/* CallUnboundCMethod0 */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { + int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); + if (likely(was_initialized == 2 && cfunc->func)) { + if (likely(cfunc->flag == METH_NOARGS)) + return __Pyx_CallCFunction(cfunc, self, NULL); + if (likely(cfunc->flag == METH_FASTCALL)) + return __Pyx_CallCFunctionFast(cfunc, self, NULL, 0); + if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) + return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, NULL, 0, NULL); + if (likely(cfunc->flag == (METH_VARARGS | METH_KEYWORDS))) + return __Pyx_CallCFunctionWithKeywords(cfunc, self, __pyx_mstate_global->__pyx_empty_tuple, NULL); + if (cfunc->flag == METH_VARARGS) + return __Pyx_CallCFunction(cfunc, self, __pyx_mstate_global->__pyx_empty_tuple); + return __Pyx__CallUnboundCMethod0(cfunc, self); + } +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + else if (unlikely(was_initialized == 1)) { + __Pyx_CachedCFunction tmp_cfunc = { +#ifndef __cplusplus + 0 +#endif + }; + tmp_cfunc.type = cfunc->type; + tmp_cfunc.method_name = cfunc->method_name; + return __Pyx__CallUnboundCMethod0(&tmp_cfunc, self); + } +#endif + PyObject *result = __Pyx__CallUnboundCMethod0(cfunc, self); + __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); + return result; +} +#endif +static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { + PyObject *result; + if (unlikely(!cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; + result = __Pyx_PyObject_CallOneArg(cfunc->method, self); + return result; +} + +/* py_dict_items (used by OwnedDictNext) */ +static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d) { + return __Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_items, d); +} + +/* py_dict_values (used by OwnedDictNext) */ +static CYTHON_INLINE PyObject* __Pyx_PyDict_Values(PyObject* d) { + return __Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_values, d); +} + +/* OwnedDictNext (used by ParseKeywordsImpl) */ +#if CYTHON_AVOID_BORROWED_REFS +static int __Pyx_PyDict_NextRef(PyObject *p, PyObject **ppos, PyObject **pkey, PyObject **pvalue) { + PyObject *next = NULL; + if (!*ppos) { + if (pvalue) { + PyObject *dictview = pkey ? __Pyx_PyDict_Items(p) : __Pyx_PyDict_Values(p); + if (unlikely(!dictview)) goto bad; + *ppos = PyObject_GetIter(dictview); + Py_DECREF(dictview); + } else { + *ppos = PyObject_GetIter(p); + } + if (unlikely(!*ppos)) goto bad; + } + next = PyIter_Next(*ppos); + if (!next) { + if (PyErr_Occurred()) goto bad; + return 0; + } + if (pkey && pvalue) { + *pkey = __Pyx_PySequence_ITEM(next, 0); + if (unlikely(*pkey)) goto bad; + *pvalue = __Pyx_PySequence_ITEM(next, 1); + if (unlikely(*pvalue)) goto bad; + Py_DECREF(next); + } else if (pkey) { + *pkey = next; + } else { + assert(pvalue); + *pvalue = next; + } + return 1; + bad: + Py_XDECREF(next); +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000 + PyErr_FormatUnraisable("Exception ignored in __Pyx_PyDict_NextRef"); +#else + PyErr_WriteUnraisable(__pyx_mstate_global->__pyx_n_u_Pyx_PyDict_NextRef); +#endif + if (pkey) *pkey = NULL; + if (pvalue) *pvalue = NULL; + return 0; +} +#else // !CYTHON_AVOID_BORROWED_REFS +static int __Pyx_PyDict_NextRef(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue) { + int result = PyDict_Next(p, ppos, pkey, pvalue); + if (likely(result == 1)) { + if (pkey) Py_INCREF(*pkey); + if (pvalue) Py_INCREF(*pvalue); + } + return result; +} +#endif + +/* RaiseDoubleKeywords (used by ParseKeywordsImpl) */ +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); +} + /* CallUnboundCMethod2 */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2) { @@ -91100,7 +90468,7 @@ static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObje } } -/* ParseKeywords */ +/* ParseKeywordsImpl (used by ParseKeywords) */ static int __Pyx_ValidateDuplicatePosArgs( PyObject *kwds, PyObject ** const argnames[], @@ -91256,16 +90624,23 @@ static void __Pyx_RejectUnknownKeyword( PyObject ** const *first_kw_arg, const char *function_name) { + #if CYTHON_AVOID_BORROWED_REFS + PyObject *pos = NULL; + #else Py_ssize_t pos = 0; + #endif PyObject *key = NULL; __Pyx_BEGIN_CRITICAL_SECTION(kwds); - while (PyDict_Next(kwds, &pos, &key, NULL)) { + while ( + #if CYTHON_AVOID_BORROWED_REFS + __Pyx_PyDict_NextRef(kwds, &pos, &key, NULL) + #else + PyDict_Next(kwds, &pos, &key, NULL) + #endif + ) { PyObject** const *name = first_kw_arg; while (*name && (**name != key)) name++; if (!*name) { - #if CYTHON_AVOID_BORROWED_REFS - Py_INCREF(key); - #endif size_t index_found = 0; int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); if (cmp != 1) { @@ -91279,12 +90654,15 @@ static void __Pyx_RejectUnknownKeyword( #endif break; } - #if CYTHON_AVOID_BORROWED_REFS - Py_DECREF(key); - #endif } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + #endif } __Pyx_END_CRITICAL_SECTION(); + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(pos); + #endif assert(PyErr_Occurred()); } static int __Pyx_ParseKeywordDict( @@ -91456,6 +90834,8 @@ static int __Pyx_ParseKeywordsTuple( #endif return -1; } + +/* ParseKeywords */ static int __Pyx_ParseKeywords( PyObject *kwds, PyObject * const *kwvalues, @@ -91501,7 +90881,7 @@ static void __Pyx_RaiseArgtupleInvalid( (num_expected == 1) ? "" : "s", num_found); } -/* ArgTypeTest */ +/* ArgTypeTestFunc (used by ArgTypeTest) */ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) { __Pyx_TypeName type_name; @@ -91549,7 +90929,7 @@ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *nam return 0; } -/* PyDictVersioning */ +/* PyDictVersioning (used by GetModuleGlobalName) */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { PyObject *dict = Py_TYPE(obj)->tp_dict; @@ -91630,69 +91010,77 @@ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { return r; } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS && !CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + int wraparound, int boundscheck, int unsafe_shared) { + CYTHON_MAYBE_UNUSED_VAR(unsafe_shared); +#if CYTHON_ASSUME_SAFE_SIZE Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyList_GET_SIZE(o); } + if ((CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS)) { + return __Pyx_PyList_GetItemRefFast(o, wrapped_i, unsafe_shared); + } else if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { - PyObject *r = PyList_GET_ITEM(o, wrapped_i); - Py_INCREF(r); - return r; + return __Pyx_NewRef(PyList_GET_ITEM(o, wrapped_i)); } return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); #else + (void)wraparound; + (void)boundscheck; return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS + int wraparound, int boundscheck, int unsafe_shared) { + CYTHON_MAYBE_UNUSED_VAR(unsafe_shared); +#if CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyTuple_GET_SIZE(o); } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { - PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); - Py_INCREF(r); - return r; + return __Pyx_NewRef(PyTuple_GET_ITEM(o, wrapped_i)); } return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); #else + (void)wraparound; + (void)boundscheck; return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + int wraparound, int boundscheck, int unsafe_shared) { + CYTHON_MAYBE_UNUSED_VAR(unsafe_shared); +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE if (is_list || PyList_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); - if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { - return __Pyx_PyList_GetItemRef(o, n); + if ((CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS)) { + return __Pyx_PyList_GetItemRefFast(o, n, unsafe_shared); + } else if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { + return __Pyx_NewRef(PyList_GET_ITEM(o, n)); } - } - else if (PyTuple_CheckExact(o)) { + } else + #if !CYTHON_AVOID_BORROWED_REFS + if (PyTuple_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { - PyObject *r = PyTuple_GET_ITEM(o, n); - Py_INCREF(r); - return r; + return __Pyx_NewRef(PyTuple_GET_ITEM(o, n)); } - } else { + } else + #endif +#endif +#if CYTHON_USE_TYPE_SLOTS && !CYTHON_COMPILING_IN_PYPY + { PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; - if (mm && mm->mp_subscript) { + if (!is_list && mm && mm->mp_subscript) { PyObject *r, *key = PyLong_FromSsize_t(i); if (unlikely(!key)) return NULL; r = mm->mp_subscript(o, key); Py_DECREF(key); return r; } - if (likely(sm && sm->sq_item)) { + if (is_list || likely(sm && sm->sq_item)) { if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { Py_ssize_t l = sm->sq_length(o); if (likely(l >= 0)) { @@ -91711,15 +91099,11 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, return PySequence_GetItem(o, i); } #endif + (void)wraparound; + (void)boundscheck; return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); } -/* PyObjectCallOneArg */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *args[2] = {NULL, arg}; - return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); -} - /* ObjectGetItem */ #if CYTHON_USE_TYPE_SLOTS static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject *index) { @@ -91727,7 +91111,7 @@ static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject *index) { Py_ssize_t key_value; key_value = __Pyx_PyIndex_AsSsize_t(index); if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { - return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); + return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1, 1); } if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { __Pyx_TypeName index_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(index)); @@ -91859,13 +91243,14 @@ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { return __Pyx_IterFinish(); } -/* PyObjectCallNoArg */ +/* PyObjectCallNoArg (used by PyObjectCallMethod0) */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { PyObject *arg[2] = {NULL, NULL}; return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } -/* PyObjectGetMethod */ +/* PyObjectGetMethod (used by PyObjectCallMethod0) */ +#if !(CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000))) static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { PyObject *attr; #if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP @@ -91954,9 +91339,16 @@ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **me *method = attr; return 0; } +#endif -/* PyObjectCallMethod0 */ +/* PyObjectCallMethod0 (used by dict_iter) */ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { +#if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000)) + PyObject *args[1] = {obj}; + (void) __Pyx_PyObject_CallOneArg; + (void) __Pyx_PyObject_CallNoArg; + return PyObject_VectorcallMethod(method_name, args, 1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +#else PyObject *method = NULL, *result = NULL; int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); if (likely(is_method)) { @@ -91969,14 +91361,15 @@ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name Py_DECREF(method); bad: return result; +#endif } -/* RaiseNoneIterError */ +/* RaiseNoneIterError (used by UnpackTupleError) */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); } -/* UnpackTupleError */ +/* UnpackTupleError (used by UnpackTuple2) */ static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) { if (t == Py_None) { __Pyx_RaiseNoneNotIterableError(); @@ -91993,7 +91386,7 @@ static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) { } } -/* UnpackTuple2 */ +/* UnpackTuple2 (used by dict_iter) */ static CYTHON_INLINE int __Pyx_unpack_tuple2( PyObject* tuple, PyObject** value1, PyObject** value2, int is_tuple, int has_known_size, int decref_tuple) { if (likely(is_tuple || PyTuple_Check(tuple))) { @@ -92065,7 +91458,7 @@ static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyOb } /* dict_iter */ -#if CYTHON_COMPILING_IN_PYPY +#if CYTHON_AVOID_BORROWED_REFS #include #endif static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name, @@ -92073,7 +91466,7 @@ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_di is_dict = is_dict || likely(PyDict_CheckExact(iterable)); *p_source_is_dict = is_dict; if (is_dict) { -#if !CYTHON_COMPILING_IN_PYPY +#if !CYTHON_AVOID_BORROWED_REFS *p_orig_length = PyDict_Size(iterable); Py_INCREF(iterable); return iterable; @@ -92102,7 +91495,7 @@ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_di iterable = __Pyx_PyObject_CallMethod0(iterable, method_name); if (!iterable) return NULL; -#if !CYTHON_COMPILING_IN_PYPY +#if !CYTHON_AVOID_BORROWED_REFS if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable)) return iterable; #endif @@ -92112,7 +91505,7 @@ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_di } return PyObject_GetIter(iterable); } -#if !CYTHON_COMPILING_IN_PYPY +#if !CYTHON_AVOID_BORROWED_REFS static CYTHON_INLINE int __Pyx_dict_iter_next_source_is_dict( PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, PyObject** pkey, PyObject** pvalue, PyObject** pitem) { @@ -92163,7 +91556,7 @@ static CYTHON_INLINE int __Pyx_dict_iter_next( PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) { PyObject* next_item; -#if !CYTHON_COMPILING_IN_PYPY +#if !CYTHON_AVOID_BORROWED_REFS if (source_is_dict) { int result; #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API @@ -92197,17 +91590,8 @@ static CYTHON_INLINE int __Pyx_dict_iter_next( #endif if (unlikely(pos >= list_size)) return 0; *ppos = pos + 1; - #if CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS - next_item = PyList_GetItemRef(iter_obj, pos); - if (unlikely(!next_item)) return -1; - #elif CYTHON_ASSUME_SAFE_MACROS - next_item = PyList_GET_ITEM(iter_obj, pos); - Py_INCREF(next_item); - #else - next_item = PyList_GetItem(iter_obj, pos); + next_item = __Pyx_PyList_GetItemRef(iter_obj, pos); if (unlikely(!next_item)) return -1; - Py_INCREF(next_item); - #endif } else #endif { @@ -92239,98 +91623,68 @@ static PyObject* __Pyx_Unpacked___Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op CYTHON_MAYBE_UNUSED_VAR(inplace); CYTHON_UNUSED_VAR(zerodivision_check); const long b = intval; - long a, x; -#ifdef HAVE_LONG_LONG + long a; const PY_LONG_LONG llb = intval; - PY_LONG_LONG lla, llx; -#endif + PY_LONG_LONG lla; if (unlikely(__Pyx_PyLong_IsZero(op1))) { return __Pyx_NewRef(op2); } - if (likely(__Pyx_PyLong_IsCompact(op1))) { - a = __Pyx_PyLong_CompactValue(op1); + const int is_positive = __Pyx_PyLong_IsPos(op1); + const digit* digits = __Pyx_PyLong_Digits(op1); + const Py_ssize_t size = __Pyx_PyLong_DigitCount(op1); + if (likely(size == 1)) { + a = (long) digits[0]; + if (!is_positive) a *= -1; } else { - const digit* digits = __Pyx_PyLong_Digits(op1); - const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(op1); switch (size) { - case -2: - if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; - #ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { - lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; - #endif - } - CYTHON_FALLTHROUGH; case 2: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; - #ifdef HAVE_LONG_LONG + if (!is_positive) a *= -1; + goto calculate_long; } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; - #endif - } - CYTHON_FALLTHROUGH; - case -3: - if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; - #ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { - lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; - #endif + if (!is_positive) lla *= -1; + goto calculate_long_long; } - CYTHON_FALLTHROUGH; + break; case 3: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; - #ifdef HAVE_LONG_LONG + if (!is_positive) a *= -1; + goto calculate_long; } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; - #endif - } - CYTHON_FALLTHROUGH; - case -4: - if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; - #ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { - lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; - #endif + if (!is_positive) lla *= -1; + goto calculate_long_long; } - CYTHON_FALLTHROUGH; + break; case 4: if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; - #ifdef HAVE_LONG_LONG + if (!is_positive) a *= -1; + goto calculate_long; } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; - #endif + if (!is_positive) lla *= -1; + goto calculate_long_long; } - CYTHON_FALLTHROUGH; - default: return PyLong_Type.tp_as_number->nb_add(op1, op2); + break; } + return PyLong_Type.tp_as_number->nb_add(op1, op2); } + calculate_long: + { + long x; x = a + b; - return PyLong_FromLong(x); -#ifdef HAVE_LONG_LONG - long_long: + return PyLong_FromLong(x); + } + calculate_long_long: + { + PY_LONG_LONG llx; llx = lla + llb; - return PyLong_FromLongLong(llx); -#endif - return __Pyx_Fallback___Pyx_PyLong_AddObjC(op1, op2, inplace); - + return PyLong_FromLongLong(llx); + } } #endif @@ -92362,8 +91716,8 @@ static CYTHON_INLINE PyObject* __Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2 #if CYTHON_VECTORCALL static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) { (void)__Pyx_PyObject_FastCallDict; - if (__Pyx_PyTuple_SET_ITEM(builder, n, key) != (0)) return -1; Py_INCREF(key); + if (__Pyx_PyTuple_SET_ITEM(builder, n, key) != (0)) return -1; args[n] = value; return 0; } @@ -92390,158 +91744,28 @@ CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyO } #endif -/* CIntToDigits */ -static const char DIGIT_PAIRS_10[2*10*10+1] = { - "00010203040506070809" - "10111213141516171819" - "20212223242526272829" - "30313233343536373839" - "40414243444546474849" - "50515253545556575859" - "60616263646566676869" - "70717273747576777879" - "80818283848586878889" - "90919293949596979899" -}; -static const char DIGIT_PAIRS_8[2*8*8+1] = { - "0001020304050607" - "1011121314151617" - "2021222324252627" - "3031323334353637" - "4041424344454647" - "5051525354555657" - "6061626364656667" - "7071727374757677" -}; -static const char DIGITS_HEX[2*16+1] = { - "0123456789abcdef" - "0123456789ABCDEF" -}; - -/* BuildPyUnicode */ -static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, const char* chars, int clength, - int prepend_sign, char padding_char) { - PyObject *uval; - Py_ssize_t uoffset = ulength - clength; -#if CYTHON_USE_UNICODE_INTERNALS - Py_ssize_t i; - void *udata; - uval = PyUnicode_New(ulength, 127); - if (unlikely(!uval)) return NULL; - udata = PyUnicode_DATA(uval); - if (uoffset > 0) { - i = 0; - if (prepend_sign) { - __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, 0, '-'); - i++; - } - for (; i < uoffset; i++) { - __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, i, padding_char); - } - } - for (i=0; i < clength; i++) { - __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, uoffset+i, chars[i]); - } -#else - { - PyObject *sign = NULL, *padding = NULL; - uval = NULL; - if (uoffset > 0) { - prepend_sign = !!prepend_sign; - if (uoffset > prepend_sign) { - padding = PyUnicode_FromOrdinal(padding_char); - if (likely(padding) && uoffset > prepend_sign + 1) { - PyObject *tmp = PySequence_Repeat(padding, uoffset - prepend_sign); - Py_DECREF(padding); - padding = tmp; - } - if (unlikely(!padding)) goto done_or_error; - } - if (prepend_sign) { - sign = PyUnicode_FromOrdinal('-'); - if (unlikely(!sign)) goto done_or_error; - } - } - uval = PyUnicode_DecodeASCII(chars, clength, NULL); - if (likely(uval) && padding) { - PyObject *tmp = PyUnicode_Concat(padding, uval); - Py_DECREF(uval); - uval = tmp; - } - if (likely(uval) && sign) { - PyObject *tmp = PyUnicode_Concat(sign, uval); - Py_DECREF(uval); - uval = tmp; - } -done_or_error: - Py_XDECREF(padding); - Py_XDECREF(sign); - } +/* CIntToPyUnicode */ +static CYTHON_INLINE PyObject* __Pyx_uchar___Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" #endif - return uval; -} - -/* COrdinalToPyUnicode */ -static CYTHON_INLINE int __Pyx_CheckUnicodeValue(int value) { - return value <= 1114111; -} -static PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t ulength, char padding_char) { - if (likely(ulength <= 250)) { - char chars[256]; - if (value <= 255) { - memset(chars, padding_char, (size_t) (ulength - 1)); - chars[ulength-1] = (char) value; - return PyUnicode_DecodeLatin1(chars, ulength, NULL); - } - char *cpos = chars + sizeof(chars); - if (value < 0x800) { - *--cpos = (char) (0x80 | (value & 0x3f)); - value >>= 6; - *--cpos = (char) (0xc0 | (value & 0x1f)); - } else if (value < 0x10000) { - *--cpos = (char) (0x80 | (value & 0x3f)); - value >>= 6; - *--cpos = (char) (0x80 | (value & 0x3f)); - value >>= 6; - *--cpos = (char) (0xe0 | (value & 0x0f)); - } else { - *--cpos = (char) (0x80 | (value & 0x3f)); - value >>= 6; - *--cpos = (char) (0x80 | (value & 0x3f)); - value >>= 6; - *--cpos = (char) (0x80 | (value & 0x3f)); - value >>= 6; - *--cpos = (char) (0xf0 | (value & 0x07)); - } - cpos -= ulength; - memset(cpos, padding_char, (size_t) (ulength - 1)); - return PyUnicode_DecodeUTF8(cpos, chars + sizeof(chars) - cpos, NULL); - } - if (value <= 127 && CYTHON_USE_UNICODE_INTERNALS) { - const char chars[1] = {(char) value}; - return __Pyx_PyUnicode_BuildFromAscii(ulength, chars, 1, 0, padding_char); + const Py_ssize_t neg_one = (Py_ssize_t) -1, const_zero = (Py_ssize_t) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!(is_unsigned || value == 0 || value > 0) || + !(sizeof(value) <= 2 || value & ~ (Py_ssize_t) 0x01fffff || __Pyx_CheckUnicodeValue((int) value)))) { + PyErr_SetString(PyExc_OverflowError, "%c arg not in range(0x110000)"); + return NULL; } - { - PyObject *uchar, *padding_uchar, *padding, *result; - padding_uchar = PyUnicode_FromOrdinal(padding_char); - if (unlikely(!padding_uchar)) return NULL; - padding = PySequence_Repeat(padding_uchar, ulength - 1); - Py_DECREF(padding_uchar); - if (unlikely(!padding)) return NULL; - uchar = PyUnicode_FromOrdinal(value); - if (unlikely(!uchar)) { - Py_DECREF(padding); - return NULL; - } - result = PyUnicode_Concat(padding, uchar); - Py_DECREF(padding); - Py_DECREF(uchar); - return result; + if (width <= 1) { + return PyUnicode_FromOrdinal((int) value); } + return __Pyx_PyUnicode_FromOrdinal_Padded((int) value, width, padding_char); } - -/* CIntToPyUnicode */ -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char) { +static CYTHON_INLINE PyObject* __Pyx____Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char) { char digits[sizeof(Py_ssize_t)*3+2]; char *dpos, *end = digits + sizeof(Py_ssize_t)*3+2; const char *hex_digits = DIGITS_HEX; @@ -92557,17 +91781,6 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; - if (format_char == 'c') { - if (unlikely(!(is_unsigned || value == 0 || value > 0) || - !(sizeof(value) <= 2 || value & ~ (Py_ssize_t) 0x01fffff || __Pyx_CheckUnicodeValue((int) value)))) { - PyErr_SetString(PyExc_OverflowError, "%c arg not in range(0x110000)"); - return NULL; - } - if (width <= 1) { - return PyUnicode_FromOrdinal((int) value); - } - return __Pyx_PyUnicode_FromOrdinal_Padded((int) value, width, padding_char); - } if (format_char == 'X') { hex_digits += 16; format_char = 'x'; @@ -92666,44 +91879,17 @@ static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice( } #endif // CYTHON_COMPILING_IN_CPYTHON -/* CallUnboundCMethod0 */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { - int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); - if (likely(was_initialized == 2 && cfunc->func)) { - if (likely(cfunc->flag == METH_NOARGS)) - return __Pyx_CallCFunction(cfunc, self, NULL); - if (likely(cfunc->flag == METH_FASTCALL)) - return __Pyx_CallCFunctionFast(cfunc, self, NULL, 0); - if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) - return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, NULL, 0, NULL); - if (likely(cfunc->flag == (METH_VARARGS | METH_KEYWORDS))) - return __Pyx_CallCFunctionWithKeywords(cfunc, self, __pyx_mstate_global->__pyx_empty_tuple, NULL); - if (cfunc->flag == METH_VARARGS) - return __Pyx_CallCFunction(cfunc, self, __pyx_mstate_global->__pyx_empty_tuple); - return __Pyx__CallUnboundCMethod0(cfunc, self); - } -#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING - else if (unlikely(was_initialized == 1)) { - __Pyx_CachedCFunction tmp_cfunc = { -#ifndef __cplusplus - 0 -#endif - }; - tmp_cfunc.type = cfunc->type; - tmp_cfunc.method_name = cfunc->method_name; - return __Pyx__CallUnboundCMethod0(&tmp_cfunc, self); - } -#endif - PyObject *result = __Pyx__CallUnboundCMethod0(cfunc, self); - __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); - return result; +/* PyObjectFormatAndDecref */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f) { + if (unlikely(!s)) return NULL; + if (likely(PyUnicode_CheckExact(s))) return s; + return __Pyx_PyObject_FormatAndDecref(s, f); } -#endif -static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f) { PyObject *result; - if (unlikely(!cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; - result = __Pyx_PyObject_CallOneArg(cfunc->method, self); + if (unlikely(!s)) return NULL; + result = PyObject_Format(s, f); + Py_DECREF(s); return result; } @@ -92712,15 +91898,44 @@ static CYTHON_INLINE PyObject* __Pyx_PyDict_Keys(PyObject* d) { return __Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_keys, d); } -/* RaiseUnexpectedTypeError */ -static int -__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj) -{ +/* pybuiltin_invalid (used by pyint_simplify) */ +static void __Pyx_PyBuiltin_Invalid(PyObject *obj, const char *type_name, const char *argname) { __Pyx_TypeName obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); - PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME, - expected, obj_type_name); + if (argname) { + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got " __Pyx_FMT_TYPENAME ")", + argname, type_name, obj_type_name + ); + } else { + PyErr_Format(PyExc_TypeError, + "Expected %.200s, got " __Pyx_FMT_TYPENAME, + type_name, obj_type_name + ); + } __Pyx_DECREF_TypeName(obj_type_name); +} + +/* pyint_simplify */ +static CYTHON_INLINE int __Pyx_PyInt_FromNumber(PyObject **number_var, const char *argname, int accept_none) { + PyObject *number = *number_var; + if (likely((accept_none && number == Py_None) || PyLong_CheckExact(number))) { + return 0; + } + PyObject *int_object; + if (likely(PyNumber_Check(number))) { + int_object = PyNumber_Long(number); + if (unlikely(!int_object)) goto bad; + } else { + __Pyx_PyBuiltin_Invalid(number, "int", argname); + goto bad; + } + *number_var = int_object; + Py_DECREF(number); return 0; +bad: + *number_var = NULL; + Py_DECREF(number); + return -1; } /* SliceObject */ @@ -92785,14 +92000,6 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, return NULL; } -/* ModFloat[double] */ -static CYTHON_INLINE double __Pyx_mod_double(double a, double b, int b_is_constant) { - CYTHON_UNUSED_VAR(b_is_constant); - double r = fmod(a, b); - r += ((r != 0) & ((r < 0) ^ (b < 0))) * b; - return r; -} - /* SetItemInt */ static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { int r; @@ -92802,25 +92009,29 @@ static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { return r; } static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list, - CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + int wraparound, int boundscheck, int unsafe_shared) { + CYTHON_MAYBE_UNUSED_VAR(unsafe_shared); +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS if (is_list || PyList_CheckExact(o)) { Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o)); - if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) { + if ((CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS && !__Pyx_IS_UNIQUELY_REFERENCED(o, unsafe_shared))) { Py_INCREF(v); -#if CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS - PyList_SetItem(o, n, v); -#else - PyObject* old = PyList_GET_ITEM(o, n); + return PyList_SetItem(o, n, v); + } else if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) { + PyObject* old; + Py_INCREF(v); + old = PyList_GET_ITEM(o, n); PyList_SET_ITEM(o, n, v); Py_DECREF(old); -#endif - return 1; + return 0; } - } else { + } else +#endif +#if CYTHON_USE_TYPE_SLOTS && !CYTHON_COMPILING_IN_PYPY + { PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; - if (mm && mm->mp_ass_subscript) { + if (!is_list && mm && mm->mp_ass_subscript) { int r; PyObject *key = PyLong_FromSsize_t(i); if (unlikely(!key)) return -1; @@ -92828,7 +92039,7 @@ static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObje Py_DECREF(key); return r; } - if (likely(sm && sm->sq_ass_item)) { + if (is_list || likely(sm && sm->sq_ass_item)) { if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { Py_ssize_t l = sm->sq_length(o); if (likely(l >= 0)) { @@ -92843,24 +92054,25 @@ static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObje } } #else - if (is_list || !PyMapping_Check(o)) - { + if (is_list || !PyMapping_Check(o)) { return PySequence_SetItem(o, i, v); } #endif + (void)wraparound; + (void)boundscheck; return __Pyx_SetItemInt_Generic(o, PyLong_FromSsize_t(i), v); } /* TypeImport */ -#ifndef __PYX_HAVE_RT_ImportType_3_1_1 -#define __PYX_HAVE_RT_ImportType_3_1_1 -static PyTypeObject *__Pyx_ImportType_3_1_1(PyObject *module, const char *module_name, const char *class_name, - size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_1_1 check_size) +#ifndef __PYX_HAVE_RT_ImportType_3_2_8 +#define __PYX_HAVE_RT_ImportType_3_2_8 +static PyTypeObject *__Pyx_ImportType_3_2_8(PyObject *module, const char *module_name, const char *class_name, + size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_2_8 check_size) { PyObject *result = 0; Py_ssize_t basicsize; Py_ssize_t itemsize; -#if CYTHON_COMPILING_IN_LIMITED_API +#if defined(Py_LIMITED_API) || (defined(CYTHON_COMPILING_IN_LIMITED_API) && CYTHON_COMPILING_IN_LIMITED_API) PyObject *py_basicsize; PyObject *py_itemsize; #endif @@ -92873,7 +92085,7 @@ static PyTypeObject *__Pyx_ImportType_3_1_1(PyObject *module, const char *module module_name, class_name); goto bad; } -#if !CYTHON_COMPILING_IN_LIMITED_API +#if !( defined(Py_LIMITED_API) || (defined(CYTHON_COMPILING_IN_LIMITED_API) && CYTHON_COMPILING_IN_LIMITED_API) ) basicsize = ((PyTypeObject *)result)->tp_basicsize; itemsize = ((PyTypeObject *)result)->tp_itemsize; #else @@ -92911,7 +92123,7 @@ static PyTypeObject *__Pyx_ImportType_3_1_1(PyObject *module, const char *module module_name, class_name, size, basicsize+itemsize); goto bad; } - if (check_size == __Pyx_ImportType_CheckSize_Error_3_1_1 && + if (check_size == __Pyx_ImportType_CheckSize_Error_3_2_8 && ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " @@ -92919,7 +92131,7 @@ static PyTypeObject *__Pyx_ImportType_3_1_1(PyObject *module, const char *module module_name, class_name, size, basicsize, basicsize+itemsize); goto bad; } - else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_1_1 && (size_t)basicsize > size) { + else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_2_8 && (size_t)basicsize > size) { if (PyErr_WarnFormat(NULL, 0, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", @@ -92934,24 +92146,101 @@ static PyTypeObject *__Pyx_ImportType_3_1_1(PyObject *module, const char *module } #endif -/* FixUpExtensionType */ +/* dict_setdefault (used by FetchCommonType) */ +static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value) { + PyObject* value; +#if __PYX_LIMITED_VERSION_HEX >= 0x030F0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4) + PyDict_SetDefaultRef(d, key, default_value, &value); +#elif CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + PyObject *args[] = {d, key, default_value}; + value = PyObject_VectorcallMethod(__pyx_mstate_global->__pyx_n_u_setdefault, args, 3 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +#elif CYTHON_COMPILING_IN_LIMITED_API + value = PyObject_CallMethodObjArgs(d, __pyx_mstate_global->__pyx_n_u_setdefault, key, default_value, NULL); +#else + value = PyDict_SetDefault(d, key, default_value); + if (unlikely(!value)) return NULL; + Py_INCREF(value); +#endif + return value; +} + +/* LimitedApiGetTypeDict (used by SetItemOnTypeDict) */ +#if CYTHON_COMPILING_IN_LIMITED_API +static Py_ssize_t __Pyx_GetTypeDictOffset(void) { + PyObject *tp_dictoffset_o; + Py_ssize_t tp_dictoffset; + tp_dictoffset_o = PyObject_GetAttrString((PyObject*)(&PyType_Type), "__dictoffset__"); + if (unlikely(!tp_dictoffset_o)) return -1; + tp_dictoffset = PyLong_AsSsize_t(tp_dictoffset_o); + Py_DECREF(tp_dictoffset_o); + if (unlikely(tp_dictoffset == 0)) { + PyErr_SetString( + PyExc_TypeError, + "'type' doesn't have a dictoffset"); + return -1; + } else if (unlikely(tp_dictoffset < 0)) { + PyErr_SetString( + PyExc_TypeError, + "'type' has an unexpected negative dictoffset. " + "Please report this as Cython bug"); + return -1; + } + return tp_dictoffset; +} +static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp) { + static Py_ssize_t tp_dictoffset = 0; + if (unlikely(tp_dictoffset == 0)) { + tp_dictoffset = __Pyx_GetTypeDictOffset(); + if (unlikely(tp_dictoffset == -1 && PyErr_Occurred())) { + tp_dictoffset = 0; // try again next time? + return NULL; + } + } + return *(PyObject**)((char*)tp + tp_dictoffset); +} +#endif + +/* SetItemOnTypeDict (used by FixUpExtensionType) */ +static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v) { + int result; + PyObject *tp_dict; +#if CYTHON_COMPILING_IN_LIMITED_API + tp_dict = __Pyx_GetTypeDict(tp); + if (unlikely(!tp_dict)) return -1; +#else + tp_dict = tp->tp_dict; +#endif + result = PyDict_SetItem(tp_dict, k, v); + if (likely(!result)) { + PyType_Modified(tp); + if (unlikely(PyObject_HasAttr(v, __pyx_mstate_global->__pyx_n_u_set_name))) { + PyObject *setNameResult = PyObject_CallMethodObjArgs(v, __pyx_mstate_global->__pyx_n_u_set_name, (PyObject *) tp, k, NULL); + if (!setNameResult) return -1; + Py_DECREF(setNameResult); + } + } + return result; +} + +/* FixUpExtensionType (used by FetchCommonType) */ static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { -#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API +#if __PYX_LIMITED_VERSION_HEX > 0x030900B1 CYTHON_UNUSED_VAR(spec); CYTHON_UNUSED_VAR(type); + CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict); #else const PyType_Slot *slot = spec->slots; + int changed = 0; +#if !CYTHON_COMPILING_IN_LIMITED_API while (slot && slot->slot && slot->slot != Py_tp_members) slot++; if (slot && slot->slot == Py_tp_members) { - int changed = 0; -#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) +#if !CYTHON_COMPILING_IN_CPYTHON const -#endif +#endif // !CYTHON_COMPILING_IN_CPYTHON) PyMemberDef *memb = (PyMemberDef*) slot->pfunc; while (memb && memb->name) { if (memb->name[0] == '_' && memb->name[1] == '_') { -#if PY_VERSION_HEX < 0x030900b1 if (strcmp(memb->name, "__weaklistoffset__") == 0) { assert(memb->type == T_PYSSIZET); assert(memb->flags == READONLY); @@ -92968,18 +92257,11 @@ static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { assert(memb->type == T_PYSSIZET); assert(memb->flags == READONLY); -#if PY_VERSION_HEX >= 0x030800b4 type->tp_vectorcall_offset = memb->offset; -#else - type->tp_print = (printfunc) memb->offset; -#endif changed = 1; } -#endif -#else - if ((0)); -#endif -#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON +#endif // CYTHON_METH_FASTCALL +#if !CYTHON_COMPILING_IN_PYPY else if (strcmp(memb->name, "__module__") == 0) { PyObject *descr; assert(memb->type == T_OBJECT); @@ -92987,47 +92269,129 @@ static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject descr = PyDescr_NewMember(type, memb); if (unlikely(!descr)) return -1; - if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { - Py_DECREF(descr); + int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr); + Py_DECREF(descr); + if (unlikely(set_item_result < 0)) { return -1; } - Py_DECREF(descr); changed = 1; } -#endif +#endif // !CYTHON_COMPILING_IN_PYPY } memb++; } - if (changed) - PyType_Modified(type); } -#endif +#endif // !CYTHON_COMPILING_IN_LIMITED_API +#if !CYTHON_COMPILING_IN_PYPY + slot = spec->slots; + while (slot && slot->slot && slot->slot != Py_tp_getset) + slot++; + if (slot && slot->slot == Py_tp_getset) { + PyGetSetDef *getset = (PyGetSetDef*) slot->pfunc; + while (getset && getset->name) { + if (getset->name[0] == '_' && getset->name[1] == '_' && strcmp(getset->name, "__module__") == 0) { + PyObject *descr = PyDescr_NewGetSet(type, getset); + if (unlikely(!descr)) + return -1; + #if CYTHON_COMPILING_IN_LIMITED_API + PyObject *pyname = PyUnicode_FromString(getset->name); + if (unlikely(!pyname)) { + Py_DECREF(descr); + return -1; + } + int set_item_result = __Pyx_SetItemOnTypeDict(type, pyname, descr); + Py_DECREF(pyname); + #else + CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict); + int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr); + #endif + Py_DECREF(descr); + if (unlikely(set_item_result < 0)) { + return -1; + } + changed = 1; + } + ++getset; + } + } +#else + CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict); +#endif // !CYTHON_COMPILING_IN_PYPY + if (changed) + PyType_Modified(type); +#endif // PY_VERSION_HEX > 0x030900B1 return 0; } -/* FetchSharedCythonModule */ +/* AddModuleRef (used by FetchSharedCythonModule) */ +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + static PyObject *__Pyx_PyImport_AddModuleObjectRef(PyObject *name) { + PyObject *module_dict = PyImport_GetModuleDict(); + PyObject *m; + if (PyMapping_GetOptionalItem(module_dict, name, &m) < 0) { + return NULL; + } + if (m != NULL && PyModule_Check(m)) { + return m; + } + Py_XDECREF(m); + m = PyModule_NewObject(name); + if (m == NULL) + return NULL; + if (PyDict_CheckExact(module_dict)) { + PyObject *new_m; + (void)PyDict_SetDefaultRef(module_dict, name, m, &new_m); + Py_DECREF(m); + return new_m; + } else { + if (PyObject_SetItem(module_dict, name, m) != 0) { + Py_DECREF(m); + return NULL; + } + return m; + } + } + static PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *py_name = PyUnicode_FromString(name); + if (!py_name) return NULL; + PyObject *module = __Pyx_PyImport_AddModuleObjectRef(py_name); + Py_DECREF(py_name); + return module; + } +#elif __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#else + static PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *module = PyImport_AddModule(name); + Py_XINCREF(module); + return module; + } +#endif + +/* FetchSharedCythonModule (used by FetchCommonType) */ static PyObject *__Pyx_FetchSharedCythonABIModule(void) { return __Pyx_PyImport_AddModuleRef(__PYX_ABI_MODULE_NAME); } -/* dict_setdefault */ -static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value, - int is_safe_type) { - PyObject* value; - CYTHON_MAYBE_UNUSED_VAR(is_safe_type); -#if CYTHON_COMPILING_IN_LIMITED_API - value = PyObject_CallMethod(d, "setdefault", "OO", key, default_value); -#elif PY_VERSION_HEX >= 0x030d0000 - PyDict_SetDefaultRef(d, key, default_value, &value); +/* FetchCommonType (used by CommonTypesMetaclass) */ +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 +static PyObject* __Pyx_PyType_FromMetaclass(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *result = __Pyx_PyType_FromModuleAndSpec(module, spec, bases); + if (result && metaclass) { + PyObject *old_tp = (PyObject*)Py_TYPE(result); + Py_INCREF((PyObject*)metaclass); +#if __PYX_LIMITED_VERSION_HEX >= 0x03090000 + Py_SET_TYPE(result, metaclass); #else - value = PyDict_SetDefault(d, key, default_value); - if (unlikely(!value)) return NULL; - Py_INCREF(value); + result->ob_type = metaclass; #endif - return value; + Py_DECREF(old_tp); + } + return result; } - -/* FetchCommonType */ +#else +#define __Pyx_PyType_FromMetaclass(me, mo, s, b) PyType_FromMetaclass(me, mo, s, b) +#endif static int __Pyx_VerifyCachedType(PyObject *cached_type, const char *name, Py_ssize_t expected_basicsize) { @@ -93037,6 +92401,9 @@ static int __Pyx_VerifyCachedType(PyObject *cached_type, "Shared Cython type %.200s is not a type object", name); return -1; } + if (expected_basicsize == 0) { + return 0; // size is inherited, nothing useful to check + } #if CYTHON_COMPILING_IN_LIMITED_API PyObject *py_basicsize; py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); @@ -93056,7 +92423,7 @@ static int __Pyx_VerifyCachedType(PyObject *cached_type, } return 0; } -static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) { PyObject *abi_module = NULL, *cached_type = NULL, *abi_module_dict, *new_cached_type, *py_object_name; int get_item_ref_result; const char* object_name = strrchr(spec->name, '.'); @@ -93079,11 +92446,13 @@ static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec } else if (unlikely(get_item_ref_result == -1)) { goto bad; } - CYTHON_UNUSED_VAR(module); - cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases); + cached_type = __Pyx_PyType_FromMetaclass( + metaclass, + CYTHON_USE_MODULE_STATE ? module : abi_module, + spec, bases); if (unlikely(!cached_type)) goto bad; if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; - new_cached_type = __Pyx_PyDict_SetDefault(abi_module_dict, py_object_name, cached_type, 1); + new_cached_type = __Pyx_PyDict_SetDefault(abi_module_dict, py_object_name, cached_type); if (unlikely(new_cached_type != cached_type)) { if (unlikely(!new_cached_type)) goto bad; Py_DECREF(cached_type); @@ -93109,7 +92478,57 @@ static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec goto done; } -/* CallTypeTraverse */ +/* CommonTypesMetaclass (used by CythonFunctionShared) */ +static PyObject* __pyx_CommonTypesMetaclass_get_module(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED void* context) { + return PyUnicode_FromString(__PYX_ABI_MODULE_NAME); +} +#if __PYX_LIMITED_VERSION_HEX < 0x030A0000 +static PyObject* __pyx_CommonTypesMetaclass_call(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED PyObject *args, CYTHON_UNUSED PyObject *kwds) { + PyErr_SetString(PyExc_TypeError, "Cannot instantiate Cython internal types"); + return NULL; +} +static int __pyx_CommonTypesMetaclass_setattr(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED PyObject *attr, CYTHON_UNUSED PyObject *value) { + PyErr_SetString(PyExc_TypeError, "Cython internal types are immutable"); + return -1; +} +#endif +static PyGetSetDef __pyx_CommonTypesMetaclass_getset[] = { + {"__module__", __pyx_CommonTypesMetaclass_get_module, NULL, NULL, NULL}, + {0, 0, 0, 0, 0} +}; +static PyType_Slot __pyx_CommonTypesMetaclass_slots[] = { + {Py_tp_getset, (void *)__pyx_CommonTypesMetaclass_getset}, + #if __PYX_LIMITED_VERSION_HEX < 0x030A0000 + {Py_tp_call, (void*)__pyx_CommonTypesMetaclass_call}, + {Py_tp_new, (void*)__pyx_CommonTypesMetaclass_call}, + {Py_tp_setattro, (void*)__pyx_CommonTypesMetaclass_setattr}, + #endif + {0, 0} +}; +static PyType_Spec __pyx_CommonTypesMetaclass_spec = { + __PYX_TYPE_MODULE_PREFIX "_common_types_metatype", + 0, + 0, + Py_TPFLAGS_IMMUTABLETYPE | + Py_TPFLAGS_DISALLOW_INSTANTIATION | + Py_TPFLAGS_DEFAULT, + __pyx_CommonTypesMetaclass_slots +}; +static int __pyx_CommonTypesMetaclass_init(PyObject *module) { + __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); + PyObject *bases = PyTuple_Pack(1, &PyType_Type); + if (unlikely(!bases)) { + return -1; + } + mstate->__pyx_CommonTypesMetaclassType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx_CommonTypesMetaclass_spec, bases); + Py_DECREF(bases); + if (unlikely(mstate->__pyx_CommonTypesMetaclassType == NULL)) { + return -1; + } + return 0; +} + +/* CallTypeTraverse (used by CythonFunctionShared) */ #if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) #else static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg) { @@ -93128,7 +92547,7 @@ static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visi } #endif -/* PyMethodNew */ +/* PyMethodNew (used by CythonFunctionShared) */ #if CYTHON_COMPILING_IN_LIMITED_API static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { PyObject *result; @@ -93154,15 +92573,20 @@ static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *ty } #endif -/* PyVectorcallFastCallDict */ -#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) +/* PyVectorcallFastCallDict (used by CythonFunctionShared) */ +#if CYTHON_METH_FASTCALL && CYTHON_VECTORCALL static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) { PyObject *res = NULL; PyObject *kwnames; PyObject **newargs; PyObject **kwvalues; - Py_ssize_t i, pos; + Py_ssize_t i; + #if CYTHON_AVOID_BORROWED_REFS + PyObject *pos; + #else + Py_ssize_t pos; + #endif size_t j; PyObject *key, *value; unsigned long keys_are_strings; @@ -93184,17 +92608,16 @@ static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vector return NULL; } kwvalues = newargs + nargs; - pos = i = 0; + pos = 0; + i = 0; keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; - while (PyDict_Next(kw, &pos, &key, &value)) { + while (__Pyx_PyDict_NextRef(kw, &pos, &key, &value)) { keys_are_strings &= #if CYTHON_COMPILING_IN_LIMITED_API PyType_GetFlags(Py_TYPE(key)); #else Py_TYPE(key)->tp_flags; #endif - Py_INCREF(key); - Py_INCREF(value); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(PyTuple_SetItem(kwnames, i, key) < 0)) goto cleanup; #else @@ -93209,6 +92632,9 @@ static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vector } res = vc(func, newargs, nargs, kwnames); cleanup: + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(pos); + #endif Py_DECREF(kwnames); for (i = 0; i < nkw; i++) Py_DECREF(kwvalues[i]); @@ -93237,7 +92663,7 @@ static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, _ } #endif -/* CythonFunctionShared */ +/* CythonFunctionShared (used by CythonFunction) */ #if CYTHON_COMPILING_IN_LIMITED_API static CYTHON_INLINE int __Pyx__IsSameCyOrCFunctionNoMethod(PyObject *func, void (*cfunc)(void)) { if (__Pyx_CyFunction_Check(func)) { @@ -93389,9 +92815,11 @@ __Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void __Pyx_END_CRITICAL_SECTION(); return 0; } +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 static PyObject * -__Pyx_CyFunction_get_dict_locked(__pyx_CyFunctionObject *op) +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) { + CYTHON_UNUSED_VAR(context); if (unlikely(op->func_dict == NULL)) { op->func_dict = PyDict_New(); if (unlikely(op->func_dict == NULL)) @@ -93400,36 +92828,7 @@ __Pyx_CyFunction_get_dict_locked(__pyx_CyFunctionObject *op) Py_INCREF(op->func_dict); return op->func_dict; } -static PyObject * -__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(context); - PyObject *result; - __Pyx_BEGIN_CRITICAL_SECTION(op); - result = __Pyx_CyFunction_get_dict_locked(op); - __Pyx_END_CRITICAL_SECTION(); - return result; -} -static int -__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context) -{ - CYTHON_UNUSED_VAR(context); - if (unlikely(value == NULL)) { - PyErr_SetString(PyExc_TypeError, - "function's dictionary may not be deleted"); - return -1; - } - if (unlikely(!PyDict_Check(value))) { - PyErr_SetString(PyExc_TypeError, - "setting function's dictionary to a non-dict"); - return -1; - } - Py_INCREF(value); - __Pyx_BEGIN_CRITICAL_SECTION(op); - __Pyx_Py_XDECREF_SET(op->func_dict, value); - __Pyx_END_CRITICAL_SECTION(); - return 0; -} +#endif static PyObject * __Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) { @@ -93557,6 +92956,7 @@ __Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { __Pyx_END_CRITICAL_SECTION(); return result; } +static int __Pyx_CyFunction_set_annotate_in_dict_if_exists(PyObject *op_in, PyObject *value); static int __Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { CYTHON_UNUSED_VAR(context); @@ -93571,8 +92971,54 @@ __Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, vo __Pyx_BEGIN_CRITICAL_SECTION(op); __Pyx_Py_XDECREF_SET(op->func_annotations, value); __Pyx_END_CRITICAL_SECTION(); + if (unlikely(__Pyx_CyFunction_set_annotate_in_dict_if_exists((PyObject*) op, Py_None) < 0)) return -1; return 0; } +static int +__Pyx_CyFunction_get_dict_if_exists(PyObject *op_in, PyObject **dict) { + /* Return 1 if the function dict exists, 0 otherwise. This cannot fail: + * _PyObject_GetDictPtr() may clear errors internally, but never reports them. */ +#if CYTHON_COMPILING_IN_PYPY + *dict = PyObject_GenericGetDict(op_in, NULL); +#elif CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX < 0x030C0000 + *dict = ((__pyx_CyFunctionObject*) op_in)->func_dict; +#else + PyObject **dictptr = _PyObject_GetDictPtr(op_in); + *dict = likely(dictptr) ? *dictptr : NULL; +#endif + return *dict ? 1 : 0; +} +static int +__Pyx_CyFunction_get_annotate_from_dict_if_exists(PyObject *op_in, PyObject **annotate) { + PyObject *dict; + int dict_found; + *annotate = NULL; + dict_found = __Pyx_CyFunction_get_dict_if_exists(op_in, &dict); + if (!dict_found) return 0; + return __Pyx_PyDict_GetItemRef(dict, __pyx_mstate_global->__pyx_n_u_annotate, annotate); +} +static int +__Pyx_CyFunction_set_annotate_in_dict_if_exists(PyObject *op_in, PyObject *value) { + PyObject *dict; + int dict_found; + dict_found = __Pyx_CyFunction_get_dict_if_exists(op_in, &dict); + if (!dict_found) return 0; + return PyDict_SetItem(dict, __pyx_mstate_global->__pyx_n_u_annotate, value); +} +static int +__Pyx_CyFunction_set_annotate_in_dict(PyObject *op_in, PyObject *value) { + PyObject *dict; + int result; +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + dict = __Pyx_CyFunction_get_dict((__pyx_CyFunctionObject*) op_in, NULL); +#else + dict = PyObject_GenericGetDict(op_in, NULL); +#endif + if (unlikely(!dict)) return -1; + result = PyDict_SetItem(dict, __pyx_mstate_global->__pyx_n_u_annotate, value); + Py_DECREF(dict); + return result; +} static PyObject * __Pyx_CyFunction_get_annotations_locked(__pyx_CyFunctionObject *op) { PyObject* result = op->func_annotations; @@ -93585,14 +93031,88 @@ __Pyx_CyFunction_get_annotations_locked(__pyx_CyFunctionObject *op) { return result; } static PyObject * -__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { - PyObject *result; +__Pyx_CyFunction_get_annotations(PyObject *op_in, void *context) { + PyObject *annotate = NULL; + PyObject *result = NULL; + __pyx_CyFunctionObject *op = (__pyx_CyFunctionObject*) op_in; CYTHON_UNUSED_VAR(context); - __Pyx_BEGIN_CRITICAL_SECTION(op); - result = __Pyx_CyFunction_get_annotations_locked(op); + __Pyx_BEGIN_CRITICAL_SECTION(op_in); + result = __Pyx_XNewRef(op->func_annotations); + __Pyx_END_CRITICAL_SECTION(); + if (result) return result; + if (unlikely(__Pyx_CyFunction_get_annotate_from_dict_if_exists(op_in, &annotate) < 0)) return NULL; + if (!annotate || annotate == Py_None) { + Py_XDECREF(annotate); + __Pyx_BEGIN_CRITICAL_SECTION(op_in); + result = __Pyx_CyFunction_get_annotations_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; + } + PyObject *format = PyLong_FromLong(1L); // annotationlib.Format.VALUE + if (likely(format)) { + result = __Pyx_PyObject_CallOneArg(annotate, format); + Py_DECREF(format); + } + Py_DECREF(annotate); + if (unlikely(!result)) return NULL; + if (unlikely(!PyDict_Check(result))) { + PyErr_SetString(PyExc_TypeError, "__annotate__ must return a dict"); + Py_DECREF(result); + return NULL; + } + __Pyx_BEGIN_CRITICAL_SECTION(op_in); + __Pyx_Py_XDECREF_SET(op->func_annotations, __Pyx_NewRef(result)); __Pyx_END_CRITICAL_SECTION(); return result; } +static PyObject *__Pyx_CyFunction_annotate_impl(PyObject *self, PyObject *args) { + CYTHON_UNUSED_VAR(args); + if (unlikely(!self)) { + PyErr_SetString(PyExc_SystemError, "cython __annotate__ called without 'self' argument"); + } + Py_XINCREF(self); + return self; +} +static PyMethodDef __Pyx_CyFunction_annotate_method = { + "__annotate__", + (PyCFunction)(void (*)(void))__Pyx_CyFunction_annotate_impl, + METH_VARARGS, + "Placeholder __annotate__ function to allow 'functools.wraps' to work " + "on Cython functions." +}; +static PyObject * +__Pyx_CyFunction_get_annotate(PyObject *op_in, void *context) { + PyObject *annotate = NULL; + CYTHON_UNUSED_VAR(context); + if (unlikely(__Pyx_CyFunction_get_annotate_from_dict_if_exists(op_in, &annotate) < 0)) return NULL; + if (annotate) return annotate; + PyObject *annotations = __Pyx_CyFunction_get_annotations(op_in, NULL); + if (unlikely(!annotations)) return NULL; + PyObject *method = PyCFunction_New( + &__Pyx_CyFunction_annotate_method, + annotations); + Py_DECREF(annotations); + return method; +} +static int +__Pyx_CyFunction_set_annotate(PyObject *op_in, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (value == NULL) { + PyErr_SetString(PyExc_TypeError, "__annotate__ cannot be deleted"); + return -1; + } + if (unlikely(value != Py_None && !PyCallable_Check(value))) { + PyErr_SetString(PyExc_TypeError, "__annotate__ must be callable or None"); + return -1; + } + if (value != Py_None) { + __pyx_CyFunctionObject *op = (__pyx_CyFunctionObject*) op_in; + __Pyx_BEGIN_CRITICAL_SECTION(op_in); + Py_CLEAR(op->func_annotations); + __Pyx_END_CRITICAL_SECTION(); + } + return __Pyx_CyFunction_set_annotate_in_dict(op_in, value); +} static PyObject * __Pyx_CyFunction_get_is_coroutine_value(__pyx_CyFunctionObject *op) { int is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; @@ -93605,7 +93125,6 @@ __Pyx_CyFunction_get_is_coroutine_value(__pyx_CyFunctionObject *op) { PyList_SET_ITEM(fromlist, 0, marker); #else if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { - Py_DECREF(marker); Py_DECREF(fromlist); return NULL; } @@ -93691,8 +93210,13 @@ static PyGetSetDef __pyx_CyFunction_getsets[] = { {"func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, {"__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, {"__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, - {"func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, - {"__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + {"func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)PyObject_GenericSetDict, 0, 0}, + {"__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)PyObject_GenericSetDict, 0, 0}, +#else + {"func_dict", (getter)PyObject_GenericGetDict, (setter)PyObject_GenericSetDict, 0, 0}, + {"__dict__", (getter)PyObject_GenericGetDict, (setter)PyObject_GenericSetDict, 0, 0}, +#endif {"func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, {"__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, {"func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, @@ -93703,6 +93227,7 @@ static PyGetSetDef __pyx_CyFunction_getsets[] = { {"__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, {"__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, {"__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {"__annotate__", (getter)__Pyx_CyFunction_get_annotate, (setter)__Pyx_CyFunction_set_annotate, 0, 0}, {"_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, #if CYTHON_COMPILING_IN_LIMITED_API {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, @@ -93713,9 +93238,11 @@ static PyMemberDef __pyx_CyFunction_members[] = { #if !CYTHON_COMPILING_IN_LIMITED_API {"__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, #endif +#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API {"__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, +#endif #if CYTHON_METH_FASTCALL -#if CYTHON_BACKPORT_VECTORCALL || CYTHON_COMPILING_IN_LIMITED_API +#if CYTHON_COMPILING_IN_LIMITED_API {"__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, #else {"__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, @@ -93771,7 +93298,9 @@ static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef * Py_XINCREF(module); cf->m_module = module; #endif +#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API op->func_dict = NULL; +#endif op->func_name = NULL; Py_INCREF(qualname); op->func_qualname = qualname; @@ -93825,14 +93354,19 @@ __Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) #else Py_CLEAR(((PyCFunctionObject*)m)->m_module); #endif +#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API Py_CLEAR(m->func_dict); +#elif PY_VERSION_HEX < 0x030d0000 + _PyObject_ClearManagedDict((PyObject*)m); +#else + PyObject_ClearManagedDict((PyObject*)m); +#endif Py_CLEAR(m->func_name); Py_CLEAR(m->func_qualname); Py_CLEAR(m->func_doc); Py_CLEAR(m->func_globals); Py_CLEAR(m->func_code); -#if !CYTHON_COMPILING_IN_LIMITED_API -#if PY_VERSION_HEX < 0x030900B1 +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); #else { @@ -93840,7 +93374,6 @@ __Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) ((PyCMethodObject *) (m))->mm_class = NULL; Py_XDECREF(cls); } -#endif #endif Py_CLEAR(m->defaults_tuple); Py_CLEAR(m->defaults_kwdict); @@ -93873,17 +93406,29 @@ static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, #else Py_VISIT(((PyCFunctionObject*)m)->m_module); #endif +#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API Py_VISIT(m->func_dict); +#else + { + int e = +#if PY_VERSION_HEX < 0x030d0000 + _PyObject_VisitManagedDict +#else + PyObject_VisitManagedDict +#endif + ((PyObject*)m, visit, arg); + if (e != 0) return e; + } +#endif __Pyx_VISIT_CONST(m->func_name); __Pyx_VISIT_CONST(m->func_qualname); Py_VISIT(m->func_doc); Py_VISIT(m->func_globals); __Pyx_VISIT_CONST(m->func_code); -#if !CYTHON_COMPILING_IN_LIMITED_API Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); -#endif Py_VISIT(m->defaults_tuple); Py_VISIT(m->defaults_kwdict); + Py_VISIT(m->func_annotations); Py_VISIT(m->func_is_coroutine); Py_VISIT(m->defaults); return 0; @@ -93985,7 +93530,7 @@ static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *a static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { PyObject *result; __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; -#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) +#if CYTHON_METH_FASTCALL && CYTHON_VECTORCALL __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); if (vc) { #if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE @@ -94024,7 +93569,7 @@ static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, P } return result; } -#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) +#if CYTHON_METH_FASTCALL && CYTHON_VECTORCALL static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) { int ret = 0; @@ -94046,11 +93591,7 @@ static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionO static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif PyObject *self; #if CYTHON_COMPILING_IN_LIMITED_API PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); @@ -94085,11 +93626,7 @@ static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *c static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif PyObject *self; #if CYTHON_COMPILING_IN_LIMITED_API PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); @@ -94124,11 +93661,7 @@ static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif PyObject *self; #if CYTHON_COMPILING_IN_LIMITED_API PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); @@ -94159,11 +93692,7 @@ static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif PyObject *self; #if CYTHON_COMPILING_IN_LIMITED_API PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); @@ -94188,7 +93717,12 @@ static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject default: return NULL; } - return ((__Pyx_PyCMethod)(void(*)(void))meth)(self, cls, args, (size_t)nargs, kwnames); + #if PY_VERSION_HEX < 0x030e00A6 + size_t nargs_value = (size_t) nargs; + #else + Py_ssize_t nargs_value = nargs; + #endif + return ((__Pyx_PyCMethod)(void(*)(void))meth)(self, cls, args, nargs_value, kwnames); } #endif static PyType_Slot __pyx_CyFunctionType_slots[] = { @@ -94217,15 +93751,17 @@ static PyType_Spec __pyx_CyFunctionType_spec = { _Py_TPFLAGS_HAVE_VECTORCALL | #endif #endif // CYTHON_METH_FASTCALL -#if PY_VERSION_HEX >= 0x030A0000 - Py_TPFLAGS_IMMUTABLETYPE | +#if PY_VERSION_HEX >= 0x030C0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_TPFLAGS_MANAGED_DICT | #endif + Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, __pyx_CyFunctionType_slots }; static int __pyx_CyFunction_init(PyObject *module) { __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); - mstate->__pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); + mstate->__pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec( + mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_CyFunctionType_spec, NULL); if (unlikely(mstate->__pyx_CyFunctionType == NULL)) { return -1; } @@ -94412,13 +93948,13 @@ static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bas return (PyObject*) metaclass; } -/* PyObjectCall2Args */ +/* PyObjectCall2Args (used by Py3ClassCreate) */ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { PyObject *args[3] = {NULL, arg1, arg2}; return __Pyx_PyObject_FastCall(function, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } -/* PyObjectLookupSpecial */ +/* PyObjectLookupSpecial (used by Py3ClassCreate) */ #if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx__PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name, int with_error) { PyObject *res; @@ -94513,19 +94049,102 @@ static PyObject *__Pyx_PyList_Pack(Py_ssize_t n, ...) { return l; } -/* Import */ -static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { +/* ImportImpl (used by Import) */ +static int __Pyx__Import_GetModule(PyObject *qualname, PyObject **module) { + PyObject *imported_module = PyImport_GetModule(qualname); + if (unlikely(!imported_module)) { + *module = NULL; + if (PyErr_Occurred()) { + return -1; + } + return 0; + } + *module = imported_module; + return 1; +} +static int __Pyx__Import_Lookup(PyObject *qualname, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject **module) { + PyObject *imported_module; + PyObject *top_level_package_name; + Py_ssize_t i; + int status, module_found; + Py_ssize_t dot_index; + module_found = __Pyx__Import_GetModule(qualname, &imported_module); + if (unlikely(!module_found || module_found == -1)) { + *module = NULL; + return module_found; + } + if (imported_names) { + for (i = 0; i < len_imported_names; i++) { + PyObject *imported_name = imported_names[i]; +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 + int has_imported_attribute = PyObject_HasAttr(imported_module, imported_name); +#else + int has_imported_attribute = PyObject_HasAttrWithError(imported_module, imported_name); + if (unlikely(has_imported_attribute == -1)) goto error; +#endif + if (!has_imported_attribute) { + goto not_found; + } + } + *module = imported_module; + return 1; + } + dot_index = PyUnicode_FindChar(qualname, '.', 0, PY_SSIZE_T_MAX, 1); + if (dot_index == -1) { + *module = imported_module; + return 1; + } + if (unlikely(dot_index == -2)) goto error; + top_level_package_name = PyUnicode_Substring(qualname, 0, dot_index); + if (unlikely(!top_level_package_name)) goto error; + Py_DECREF(imported_module); + status = __Pyx__Import_GetModule(top_level_package_name, module); + Py_DECREF(top_level_package_name); + return status; +error: + Py_DECREF(imported_module); + *module = NULL; + return -1; +not_found: + Py_DECREF(imported_module); + *module = NULL; + return 0; +} +static PyObject *__Pyx__Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, PyObject *moddict, int level) { PyObject *module = 0; PyObject *empty_dict = 0; - PyObject *empty_list = 0; + PyObject *from_list = 0; + int module_found; + if (!qualname) { + qualname = name; + } + module_found = __Pyx__Import_Lookup(qualname, imported_names, len_imported_names, &module); + if (likely(module_found == 1)) { + return module; + } else if (unlikely(module_found == -1)) { + return NULL; + } empty_dict = PyDict_New(); if (unlikely(!empty_dict)) goto bad; + if (imported_names) { +#if CYTHON_COMPILING_IN_CPYTHON + from_list = __Pyx_PyList_FromArray(imported_names, len_imported_names); + if (unlikely(!from_list)) + goto bad; +#else + from_list = PyList_New(len_imported_names); + if (unlikely(!from_list)) goto bad; + for (Py_ssize_t i=0; i__pyx_d, empty_dict, from_list, 1); + name, moddict, empty_dict, from_list, 1); if (unlikely(!module)) { if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) goto bad; @@ -94536,14 +94155,19 @@ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { } if (!module) { module = PyImport_ImportModuleLevelObject( - name, __pyx_mstate_global->__pyx_d, empty_dict, from_list, level); + name, moddict, empty_dict, from_list, level); } bad: + Py_XDECREF(from_list); Py_XDECREF(empty_dict); - Py_XDECREF(empty_list); return module; } +/* Import */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, int level) { + return __Pyx__Import(name, imported_names, len_imported_names, qualname, __pyx_mstate_global->__pyx_d, level); +} + /* ImportFrom */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); @@ -94583,140 +94207,8 @@ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { return value; } -/* ImportDottedModule */ -static PyObject *__Pyx__ImportDottedModule_Error(PyObject *name, PyObject *parts_tuple, Py_ssize_t count) { - PyObject *partial_name = NULL, *slice = NULL, *sep = NULL; - Py_ssize_t size; - if (unlikely(PyErr_Occurred())) { - PyErr_Clear(); - } -#if CYTHON_ASSUME_SAFE_SIZE - size = PyTuple_GET_SIZE(parts_tuple); -#else - size = PyTuple_Size(parts_tuple); - if (size < 0) goto bad; -#endif - if (likely(size == count)) { - partial_name = name; - } else { - slice = PySequence_GetSlice(parts_tuple, 0, count); - if (unlikely(!slice)) - goto bad; - sep = PyUnicode_FromStringAndSize(".", 1); - if (unlikely(!sep)) - goto bad; - partial_name = PyUnicode_Join(sep, slice); - } - PyErr_Format( - PyExc_ModuleNotFoundError, - "No module named '%U'", partial_name); -bad: - Py_XDECREF(sep); - Py_XDECREF(slice); - Py_XDECREF(partial_name); - return NULL; -} -static PyObject *__Pyx__ImportDottedModule_Lookup(PyObject *name) { - PyObject *imported_module; -#if (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) ||\ - CYTHON_COMPILING_IN_GRAAL - PyObject *modules = PyImport_GetModuleDict(); - if (unlikely(!modules)) - return NULL; - imported_module = __Pyx_PyDict_GetItemStr(modules, name); - Py_XINCREF(imported_module); -#else - imported_module = PyImport_GetModule(name); -#endif - return imported_module; -} -static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple) { - Py_ssize_t i, nparts; -#if CYTHON_ASSUME_SAFE_SIZE - nparts = PyTuple_GET_SIZE(parts_tuple); -#else - nparts = PyTuple_Size(parts_tuple); - if (nparts < 0) return NULL; -#endif - for (i=1; i < nparts && module; i++) { - PyObject *part, *submodule; -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - part = PyTuple_GET_ITEM(parts_tuple, i); -#else - part = __Pyx_PySequence_ITEM(parts_tuple, i); - if (!part) return NULL; -#endif - submodule = __Pyx_PyObject_GetAttrStrNoError(module, part); -#if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) - Py_DECREF(part); -#endif - Py_DECREF(module); - module = submodule; - } - if (unlikely(!module)) { - return __Pyx__ImportDottedModule_Error(name, parts_tuple, i); - } - return module; -} -static PyObject *__Pyx__ImportDottedModule(PyObject *name, PyObject *parts_tuple) { - PyObject *imported_module; - PyObject *module = __Pyx_Import(name, NULL, 0); - if (!parts_tuple || unlikely(!module)) - return module; - imported_module = __Pyx__ImportDottedModule_Lookup(name); - if (likely(imported_module)) { - Py_DECREF(module); - return imported_module; - } - PyErr_Clear(); - return __Pyx_ImportDottedModule_WalkParts(module, name, parts_tuple); -} -static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple) { -#if CYTHON_COMPILING_IN_CPYTHON - PyObject *module = __Pyx__ImportDottedModule_Lookup(name); - if (likely(module)) { - PyObject *spec = __Pyx_PyObject_GetAttrStrNoError(module, __pyx_mstate_global->__pyx_n_u_spec); - if (likely(spec)) { - PyObject *unsafe = __Pyx_PyObject_GetAttrStrNoError(spec, __pyx_mstate_global->__pyx_n_u_initializing); - if (likely(!unsafe || !__Pyx_PyObject_IsTrue(unsafe))) { - Py_DECREF(spec); - spec = NULL; - } - Py_XDECREF(unsafe); - } - if (likely(!spec)) { - PyErr_Clear(); - return module; - } - Py_DECREF(spec); - Py_DECREF(module); - } else if (PyErr_Occurred()) { - PyErr_Clear(); - } -#endif - return __Pyx__ImportDottedModule(name, parts_tuple); -} - -/* ImportDottedModuleRelFirst */ -static PyObject *__Pyx_ImportDottedModuleRelFirst(PyObject *name, PyObject *parts_tuple) { - PyObject *module; - PyObject *from_list = NULL; - module = __Pyx_Import(name, from_list, -1); - Py_XDECREF(from_list); - if (module) { - if (parts_tuple) { - module = __Pyx_ImportDottedModule_WalkParts(module, name, parts_tuple); - } - return module; - } - if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) - return NULL; - PyErr_Clear(); - return __Pyx_ImportDottedModule(name, parts_tuple); -} - -/* PyObjectCallMethod1 */ -#if !(CYTHON_VECTORCALL && __PYX_LIMITED_VERSION_HEX >= 0x030C0000) +/* PyObjectCallMethod1 (used by append) */ +#if !(CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000))) static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) { PyObject *result = __Pyx_PyObject_CallOneArg(method, arg); Py_DECREF(method); @@ -94724,9 +94216,8 @@ static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) { } #endif static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { -#if CYTHON_VECTORCALL && __PYX_LIMITED_VERSION_HEX >= 0x030C0000 +#if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000)) PyObject *args[2] = {obj, arg}; - (void) __Pyx_PyObject_GetMethod; (void) __Pyx_PyObject_CallOneArg; (void) __Pyx_PyObject_Call2Args; return PyObject_VectorcallMethod(method_name, args, 2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); @@ -94756,55 +94247,44 @@ static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x) { return 0; } -/* CLineInTraceback */ +/* CLineInTraceback (used by AddTraceback) */ #if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 +#define __Pyx_PyProbablyModule_GetDict(o) __Pyx_XNewRef(PyModule_GetDict(o)) +#elif !CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __Pyx_PyProbablyModule_GetDict(o) PyObject_GenericGetDict(o, NULL); +#else +PyObject* __Pyx_PyProbablyModule_GetDict(PyObject *o) { + PyObject **dict_ptr = _PyObject_GetDictPtr(o); + return dict_ptr ? __Pyx_XNewRef(*dict_ptr) : NULL; +} +#endif static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { - PyObject *use_cline; + PyObject *use_cline = NULL; PyObject *ptype, *pvalue, *ptraceback; -#if CYTHON_COMPILING_IN_CPYTHON - PyObject **cython_runtime_dict; -#endif + PyObject *cython_runtime_dict; CYTHON_MAYBE_UNUSED_VAR(tstate); if (unlikely(!__pyx_mstate_global->__pyx_cython_runtime)) { return c_line; } __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); -#if CYTHON_COMPILING_IN_CPYTHON - cython_runtime_dict = _PyObject_GetDictPtr(__pyx_mstate_global->__pyx_cython_runtime); + cython_runtime_dict = __Pyx_PyProbablyModule_GetDict(__pyx_mstate_global->__pyx_cython_runtime); if (likely(cython_runtime_dict)) { - __Pyx_BEGIN_CRITICAL_SECTION(*cython_runtime_dict); __PYX_PY_DICT_LOOKUP_IF_MODIFIED( - use_cline, *cython_runtime_dict, - __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_mstate_global->__pyx_n_u_cline_in_traceback)) - Py_XINCREF(use_cline); - __Pyx_END_CRITICAL_SECTION(); - } else -#endif - { - PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_mstate_global->__pyx_cython_runtime, __pyx_mstate_global->__pyx_n_u_cline_in_traceback); - if (use_cline_obj) { - use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; - Py_INCREF(use_cline); - Py_DECREF(use_cline_obj); - } else { - PyErr_Clear(); - use_cline = NULL; - } - } - if (!use_cline) { - c_line = 0; - (void) PyObject_SetAttr(__pyx_mstate_global->__pyx_cython_runtime, __pyx_mstate_global->__pyx_n_u_cline_in_traceback, Py_False); + use_cline, cython_runtime_dict, + __Pyx_PyDict_SetDefault(cython_runtime_dict, __pyx_mstate_global->__pyx_n_u_cline_in_traceback, Py_False)) } - else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + if (use_cline == NULL || use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } Py_XDECREF(use_cline); + Py_XDECREF(cython_runtime_dict); __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } #endif -/* CodeObjectCache */ +/* CodeObjectCache (used by AddTraceback) */ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { @@ -94956,8 +94436,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, PyObject *exc_type, *exc_value, *exc_traceback; int success = 0; if (c_line) { - (void) __pyx_cfilenm; - (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); + c_line = __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); } PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); code_object = __pyx_find_code_object(c_line ? -c_line : py_line); @@ -94966,7 +94445,11 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, if (unlikely(!code_object)) goto bad; py_py_line = PyLong_FromLong(py_line); if (unlikely(!py_py_line)) goto bad; - py_funcname = PyUnicode_FromString(funcname); + if (c_line) { + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + } else { + py_funcname = PyUnicode_FromString(funcname); + } if (unlikely(!py_funcname)) goto bad; dict = PyDict_New(); if (unlikely(!dict)) goto bad; @@ -95616,10 +95099,8 @@ static CYTHON_INLINE TA_RetCode __Pyx_PyLong_As_TA_RetCode(PyObject *x) { #endif if ((sizeof(TA_RetCode) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(TA_RetCode, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG } else if ((sizeof(TA_RetCode) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(TA_RetCode, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif } } else { #if CYTHON_USE_PYLONG_INTERNALS @@ -95688,10 +95169,8 @@ static CYTHON_INLINE TA_RetCode __Pyx_PyLong_As_TA_RetCode(PyObject *x) { #endif if ((sizeof(TA_RetCode) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(TA_RetCode, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG } else if ((sizeof(TA_RetCode) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(TA_RetCode, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif } } { @@ -95870,10 +95349,8 @@ static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *x) { #endif if ((sizeof(int) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif } } else { #if CYTHON_USE_PYLONG_INTERNALS @@ -95942,10 +95419,8 @@ static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *x) { #endif if ((sizeof(int) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif } } { @@ -96066,7 +95541,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value) { return PyLong_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); -#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY +#if !CYTHON_COMPILING_IN_PYPY } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif @@ -96074,10 +95549,8 @@ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value) { } else { if (sizeof(int) <= sizeof(long)) { return PyLong_FromLong((long) value); -#ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif } } { @@ -96121,77 +95594,6 @@ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value) { } } -/* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_RetCode(TA_RetCode value) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const TA_RetCode neg_one = (TA_RetCode) -1, const_zero = (TA_RetCode) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(TA_RetCode) < sizeof(long)) { - return PyLong_FromLong((long) value); - } else if (sizeof(TA_RetCode) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY - } else if (sizeof(TA_RetCode) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(TA_RetCode) <= sizeof(long)) { - return PyLong_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(TA_RetCode) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif - } - } - { - unsigned char *bytes = (unsigned char *)&value; -#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 - if (is_unsigned) { - return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); - } else { - return PyLong_FromNativeBytes(bytes, sizeof(value), -1); - } -#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 - int one = 1; int little = (int)*(unsigned char *)&one; - return _PyLong_FromByteArray(bytes, sizeof(TA_RetCode), - little, !is_unsigned); -#else - int one = 1; int little = (int)*(unsigned char *)&one; - PyObject *from_bytes, *result = NULL, *kwds = NULL; - PyObject *py_bytes = NULL, *order_str = NULL; - from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); - if (!from_bytes) return NULL; - py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(TA_RetCode)); - if (!py_bytes) goto limited_bad; - order_str = PyUnicode_FromString(little ? "little" : "big"); - if (!order_str) goto limited_bad; - { - PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; - if (!is_unsigned) { - kwds = __Pyx_MakeVectorcallBuilderKwds(1); - if (!kwds) goto limited_bad; - if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; - } - result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); - } - limited_bad: - Py_XDECREF(kwds); - Py_XDECREF(order_str); - Py_XDECREF(py_bytes); - Py_XDECREF(from_bytes); - return result; -#endif - } -} - /* CIntFromPy */ static CYTHON_INLINE TA_FuncUnstId __Pyx_PyLong_As_TA_FuncUnstId(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC @@ -96266,10 +95668,8 @@ static CYTHON_INLINE TA_FuncUnstId __Pyx_PyLong_As_TA_FuncUnstId(PyObject *x) { #endif if ((sizeof(TA_FuncUnstId) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(TA_FuncUnstId, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG } else if ((sizeof(TA_FuncUnstId) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(TA_FuncUnstId, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif } } else { #if CYTHON_USE_PYLONG_INTERNALS @@ -96338,10 +95738,8 @@ static CYTHON_INLINE TA_FuncUnstId __Pyx_PyLong_As_TA_FuncUnstId(PyObject *x) { #endif if ((sizeof(TA_FuncUnstId) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(TA_FuncUnstId, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG } else if ((sizeof(TA_FuncUnstId) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(TA_FuncUnstId, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif } } { @@ -96520,10 +95918,8 @@ static CYTHON_INLINE unsigned int __Pyx_PyLong_As_unsigned_int(PyObject *x) { #endif if ((sizeof(unsigned int) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG } else if ((sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif } } else { #if CYTHON_USE_PYLONG_INTERNALS @@ -96592,10 +95988,8 @@ static CYTHON_INLINE unsigned int __Pyx_PyLong_As_unsigned_int(PyObject *x) { #endif if ((sizeof(unsigned int) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG } else if ((sizeof(unsigned int) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif } } { @@ -96716,7 +96110,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_unsigned_int(unsigned int value return PyLong_FromLong((long) value); } else if (sizeof(unsigned int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); -#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY +#if !CYTHON_COMPILING_IN_PYPY } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif @@ -96724,10 +96118,8 @@ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_unsigned_int(unsigned int value } else { if (sizeof(unsigned int) <= sizeof(long)) { return PyLong_FromLong((long) value); -#ifdef HAVE_LONG_LONG } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif } } { @@ -96845,10 +96237,8 @@ static CYTHON_INLINE TA_Compatibility __Pyx_PyLong_As_TA_Compatibility(PyObject #endif if ((sizeof(TA_Compatibility) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(TA_Compatibility, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG } else if ((sizeof(TA_Compatibility) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(TA_Compatibility, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif } } else { #if CYTHON_USE_PYLONG_INTERNALS @@ -96917,10 +96307,8 @@ static CYTHON_INLINE TA_Compatibility __Pyx_PyLong_As_TA_Compatibility(PyObject #endif if ((sizeof(TA_Compatibility) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(TA_Compatibility, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG } else if ((sizeof(TA_Compatibility) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(TA_Compatibility, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif } } { @@ -97099,10 +96487,8 @@ static CYTHON_INLINE TA_CandleSettingType __Pyx_PyLong_As_TA_CandleSettingType(P #endif if ((sizeof(TA_CandleSettingType) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(TA_CandleSettingType, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG } else if ((sizeof(TA_CandleSettingType) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(TA_CandleSettingType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif } } else { #if CYTHON_USE_PYLONG_INTERNALS @@ -97171,10 +96557,8 @@ static CYTHON_INLINE TA_CandleSettingType __Pyx_PyLong_As_TA_CandleSettingType(P #endif if ((sizeof(TA_CandleSettingType) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(TA_CandleSettingType, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG } else if ((sizeof(TA_CandleSettingType) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(TA_CandleSettingType, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif } } { @@ -97353,10 +96737,8 @@ static CYTHON_INLINE TA_RangeType __Pyx_PyLong_As_TA_RangeType(PyObject *x) { #endif if ((sizeof(TA_RangeType) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(TA_RangeType, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG } else if ((sizeof(TA_RangeType) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(TA_RangeType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif } } else { #if CYTHON_USE_PYLONG_INTERNALS @@ -97425,10 +96807,8 @@ static CYTHON_INLINE TA_RangeType __Pyx_PyLong_As_TA_RangeType(PyObject *x) { #endif if ((sizeof(TA_RangeType) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(TA_RangeType, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG } else if ((sizeof(TA_RangeType) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(TA_RangeType, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif } } { @@ -97549,7 +96929,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value) { return PyLong_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); -#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY +#if !CYTHON_COMPILING_IN_PYPY } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif @@ -97557,10 +96937,8 @@ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value) { } else { if (sizeof(long) <= sizeof(long)) { return PyLong_FromLong((long) value); -#ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif } } { @@ -97620,7 +96998,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_OptInputParameterType(TA_Opt return PyLong_FromLong((long) value); } else if (sizeof(TA_OptInputParameterType) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); -#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY +#if !CYTHON_COMPILING_IN_PYPY } else if (sizeof(TA_OptInputParameterType) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif @@ -97628,10 +97006,8 @@ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_OptInputParameterType(TA_Opt } else { if (sizeof(TA_OptInputParameterType) <= sizeof(long)) { return PyLong_FromLong((long) value); -#ifdef HAVE_LONG_LONG } else if (sizeof(TA_OptInputParameterType) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif } } { @@ -97691,7 +97067,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_FuncFlags(TA_FuncFlags value return PyLong_FromLong((long) value); } else if (sizeof(TA_FuncFlags) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); -#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY +#if !CYTHON_COMPILING_IN_PYPY } else if (sizeof(TA_FuncFlags) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif @@ -97699,10 +97075,8 @@ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_FuncFlags(TA_FuncFlags value } else { if (sizeof(TA_FuncFlags) <= sizeof(long)) { return PyLong_FromLong((long) value); -#ifdef HAVE_LONG_LONG } else if (sizeof(TA_FuncFlags) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif } } { @@ -97762,7 +97136,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_InputFlags(TA_InputFlags val return PyLong_FromLong((long) value); } else if (sizeof(TA_InputFlags) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); -#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY +#if !CYTHON_COMPILING_IN_PYPY } else if (sizeof(TA_InputFlags) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif @@ -97770,10 +97144,8 @@ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_InputFlags(TA_InputFlags val } else { if (sizeof(TA_InputFlags) <= sizeof(long)) { return PyLong_FromLong((long) value); -#ifdef HAVE_LONG_LONG } else if (sizeof(TA_InputFlags) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif } } { @@ -97833,7 +97205,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_OutputFlags(TA_OutputFlags v return PyLong_FromLong((long) value); } else if (sizeof(TA_OutputFlags) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); -#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY +#if !CYTHON_COMPILING_IN_PYPY } else if (sizeof(TA_OutputFlags) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif @@ -97841,10 +97213,8 @@ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_OutputFlags(TA_OutputFlags v } else { if (sizeof(TA_OutputFlags) <= sizeof(long)) { return PyLong_FromLong((long) value); -#ifdef HAVE_LONG_LONG } else if (sizeof(TA_OutputFlags) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif } } { @@ -98001,10 +97371,8 @@ static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *x) { #endif if ((sizeof(long) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif } } else { #if CYTHON_USE_PYLONG_INTERNALS @@ -98073,10 +97441,8 @@ static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *x) { #endif if ((sizeof(long) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif } } { @@ -98269,11 +97635,8 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj #endif /* GetRuntimeVersion */ -static unsigned long __Pyx_get_runtime_version(void) { -#if __PYX_LIMITED_VERSION_HEX >= 0x030b0000 - return Py_Version & ~0xFFUL; -#else - static unsigned long __Pyx_cached_runtime_version = 0; +#if __PYX_LIMITED_VERSION_HEX < 0x030b0000 +void __Pyx_init_runtime_version(void) { if (__Pyx_cached_runtime_version == 0) { const char* rt_version = Py_GetVersion(); unsigned long version = 0; @@ -98294,6 +97657,12 @@ static unsigned long __Pyx_get_runtime_version(void) { } __Pyx_cached_runtime_version = version; } +} +#endif +static unsigned long __Pyx_get_runtime_version(void) { +#if __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + return Py_Version & ~0xFFUL; +#else return __Pyx_cached_runtime_version; #endif } @@ -98381,9 +97750,13 @@ static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt PyCode_NewWithPosOnlyArgs #endif (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, __pyx_mstate_global->__pyx_empty_bytes); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030c00A1 + if (likely(result)) + result->_co_firsttraceable = 0; + #endif return result; } -#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY +#elif !CYTHON_COMPILING_IN_PYPY #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else @@ -98395,10 +97768,10 @@ static PyObject* __Pyx_PyCode_New( PyObject * const *varnames, PyObject *filename, PyObject *funcname, - const char *line_table, + PyObject *line_table, PyObject *tuple_dedup_map ) { - PyObject *code_obj = NULL, *varnames_tuple_dedup = NULL, *code_bytes = NULL, *line_table_bytes = NULL; + PyObject *code_obj = NULL, *varnames_tuple_dedup = NULL, *code_bytes = NULL; Py_ssize_t var_count = (Py_ssize_t) descr.nlocals; PyObject *varnames_tuple = PyTuple_New(var_count); if (unlikely(!varnames_tuple)) return NULL; @@ -98419,11 +97792,12 @@ static PyObject* __Pyx_PyCode_New( #if CYTHON_AVOID_BORROWED_REFS Py_INCREF(varnames_tuple_dedup); #endif - if (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table != NULL - && !CYTHON_COMPILING_IN_GRAAL) { - line_table_bytes = PyBytes_FromStringAndSize(line_table, descr.line_table_length); - if (unlikely(!line_table_bytes)) goto done; - Py_ssize_t code_len = (descr.line_table_length * 2 + 4) & ~3; + if (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table != NULL && !CYTHON_COMPILING_IN_GRAAL) { + Py_ssize_t line_table_length = __Pyx_PyBytes_GET_SIZE(line_table); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(line_table_length == -1)) goto done; + #endif + Py_ssize_t code_len = (line_table_length * 2 + 4) & ~3LL; code_bytes = PyBytes_FromStringAndSize(NULL, code_len); if (unlikely(!code_bytes)) goto done; char* c_code_bytes = PyBytes_AsString(code_bytes); @@ -98446,11 +97820,10 @@ static PyObject* __Pyx_PyCode_New( filename, funcname, (int) descr.first_line, - (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table_bytes) ? line_table_bytes : __pyx_mstate_global->__pyx_empty_bytes + (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table) ? line_table : __pyx_mstate_global->__pyx_empty_bytes ); done: Py_XDECREF(code_bytes); - Py_XDECREF(line_table_bytes); #if CYTHON_AVOID_BORROWED_REFS Py_XDECREF(varnames_tuple_dedup); #endif @@ -98458,30 +97831,68 @@ static PyObject* __Pyx_PyCode_New( return code_obj; } -/* InitStrings */ -static int __Pyx_InitStrings(__Pyx_StringTabEntry const *t, PyObject **target, const char* const* encoding_names) { - while (t->s) { - PyObject *str; - if (t->is_unicode) { - if (t->intern) { - str = PyUnicode_InternFromString(t->s); - } else if (t->encoding) { - str = PyUnicode_Decode(t->s, t->n - 1, encoding_names[t->encoding], NULL); - } else { - str = PyUnicode_FromStringAndSize(t->s, t->n - 1); - } - } else { - str = PyBytes_FromStringAndSize(t->s, t->n - 1); - } - if (!str) - return -1; - *target = str; - if (PyObject_Hash(str) == -1) - return -1; - ++t; - ++target; +/* DecompressString */ +static PyObject *__Pyx_DecompressString(const char *s, Py_ssize_t length, int algo) { + PyObject *module = NULL, *decompress, *compressed_bytes, *decompressed; + const char* module_name = algo == 3 ? "compression.zstd" : algo == 2 ? "bz2" : "zlib"; + PyObject *methodname = PyUnicode_FromString("decompress"); + if (unlikely(!methodname)) return NULL; + #if __PYX_LIMITED_VERSION_HEX >= 0x030e0000 + if (algo == 3) { + PyObject *fromlist = Py_BuildValue("[O]", methodname); + if (unlikely(!fromlist)) goto bad; + module = PyImport_ImportModuleLevel("compression.zstd", NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + } else + #endif + module = PyImport_ImportModule(module_name); + if (unlikely(!module)) goto import_failed; + decompress = PyObject_GetAttr(module, methodname); + if (unlikely(!decompress)) goto import_failed; + { + #ifdef __cplusplus + char *memview_bytes = const_cast(s); + #else + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wcast-qual" + #elif !defined(__INTEL_COMPILER) && defined(__GNUC__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wcast-qual" + #endif + char *memview_bytes = (char*) s; + #if defined(__clang__) + #pragma clang diagnostic pop + #elif !defined(__INTEL_COMPILER) && defined(__GNUC__) + #pragma GCC diagnostic pop + #endif + #endif + #if CYTHON_COMPILING_IN_LIMITED_API && !defined(PyBUF_READ) + int memview_flags = 0x100; + #else + int memview_flags = PyBUF_READ; + #endif + compressed_bytes = PyMemoryView_FromMemory(memview_bytes, length, memview_flags); } - return 0; + if (unlikely(!compressed_bytes)) { + Py_DECREF(decompress); + goto bad; + } + decompressed = PyObject_CallFunctionObjArgs(decompress, compressed_bytes, NULL); + Py_DECREF(compressed_bytes); + Py_DECREF(decompress); + Py_DECREF(module); + Py_DECREF(methodname); + return decompressed; +import_failed: + PyErr_Format(PyExc_ImportError, + "Failed to import '%.20s.decompress' - cannot initialise module strings. " + "String compression was configured with the C macro 'CYTHON_COMPRESS_STRINGS=%d'.", + module_name, algo); +bad: + Py_XDECREF(module); + Py_DECREF(methodname); + return NULL; } #include @@ -98703,7 +98114,7 @@ static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b) { return __Pyx_NewRef(Py_None); } static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { - return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); + return __Pyx_NewRef(b ? Py_True: Py_False); } static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t ival) { return PyLong_FromSize_t(ival); diff --git a/talib/_ta_lib.pxd b/talib/_ta_lib.pxd index 65b712177..21e64b220 100644 --- a/talib/_ta_lib.pxd +++ b/talib/_ta_lib.pxd @@ -3,86 +3,86 @@ cdef extern from "ta-lib/ta_defs.h": ctypedef int TA_RetCode - TA_RetCode TA_SUCCESS = 0 - TA_RetCode TA_LIB_NOT_INITIALIZE = 1 - TA_RetCode TA_BAD_PARAM = 2 - TA_RetCode TA_ALLOC_ERR = 3 - TA_RetCode TA_GROUP_NOT_FOUND = 4 - TA_RetCode TA_FUNC_NOT_FOUND = 5 - TA_RetCode TA_INVALID_HANDLE = 6 - TA_RetCode TA_INVALID_PARAM_HOLDER = 7 - TA_RetCode TA_INVALID_PARAM_HOLDER_TYPE = 8 - TA_RetCode TA_INVALID_PARAM_FUNCTION = 9 - TA_RetCode TA_INPUT_NOT_ALL_INITIALIZE = 10 - TA_RetCode TA_OUTPUT_NOT_ALL_INITIALIZE = 11 - TA_RetCode TA_OUT_OF_RANGE_START_INDEX = 12 - TA_RetCode TA_OUT_OF_RANGE_END_INDEX = 13 - TA_RetCode TA_INVALID_LIST_TYPE = 14 - TA_RetCode TA_BAD_OBJECT = 15 - TA_RetCode TA_NOT_SUPPORTED = 16 - TA_RetCode TA_INTERNAL_ERROR = 5000 - TA_RetCode TA_UNKNOWN_ERR = 0xffff + const TA_RetCode TA_SUCCESS = 0 + const TA_RetCode TA_LIB_NOT_INITIALIZE = 1 + const TA_RetCode TA_BAD_PARAM = 2 + const TA_RetCode TA_ALLOC_ERR = 3 + const TA_RetCode TA_GROUP_NOT_FOUND = 4 + const TA_RetCode TA_FUNC_NOT_FOUND = 5 + const TA_RetCode TA_INVALID_HANDLE = 6 + const TA_RetCode TA_INVALID_PARAM_HOLDER = 7 + const TA_RetCode TA_INVALID_PARAM_HOLDER_TYPE = 8 + const TA_RetCode TA_INVALID_PARAM_FUNCTION = 9 + const TA_RetCode TA_INPUT_NOT_ALL_INITIALIZE = 10 + const TA_RetCode TA_OUTPUT_NOT_ALL_INITIALIZE = 11 + const TA_RetCode TA_OUT_OF_RANGE_START_INDEX = 12 + const TA_RetCode TA_OUT_OF_RANGE_END_INDEX = 13 + const TA_RetCode TA_INVALID_LIST_TYPE = 14 + const TA_RetCode TA_BAD_OBJECT = 15 + const TA_RetCode TA_NOT_SUPPORTED = 16 + const TA_RetCode TA_INTERNAL_ERROR = 5000 + const TA_RetCode TA_UNKNOWN_ERR = 0xffff ctypedef int TA_Compatibility - TA_Compatibility TA_COMPATIBILITY_DEFAULT = 0 - TA_Compatibility TA_COMPATIBILITY_METASTOCK = 1 + const TA_Compatibility TA_COMPATIBILITY_DEFAULT = 0 + const TA_Compatibility TA_COMPATIBILITY_METASTOCK = 1 ctypedef int TA_MAType - TA_MAType TA_MAType_SMA = 0 - TA_MAType TA_MAType_EMA = 1 - TA_MAType TA_MAType_WMA = 2 - TA_MAType TA_MAType_DEMA = 3 - TA_MAType TA_MAType_TEMA = 4 - TA_MAType TA_MAType_TRIMA = 5 - TA_MAType TA_MAType_KAMA = 6 - TA_MAType TA_MAType_MAMA = 7 - TA_MAType TA_MAType_T3 = 8 + const TA_MAType TA_MAType_SMA = 0 + const TA_MAType TA_MAType_EMA = 1 + const TA_MAType TA_MAType_WMA = 2 + const TA_MAType TA_MAType_DEMA = 3 + const TA_MAType TA_MAType_TEMA = 4 + const TA_MAType TA_MAType_TRIMA = 5 + const TA_MAType TA_MAType_KAMA = 6 + const TA_MAType TA_MAType_MAMA = 7 + const TA_MAType TA_MAType_T3 = 8 ctypedef int TA_FuncUnstId - TA_FuncUnstId TA_FUNC_UNST_ADX = 0 - TA_FuncUnstId TA_FUNC_UNST_ADXR = 1 - TA_FuncUnstId TA_FUNC_UNST_ATR = 2 - TA_FuncUnstId TA_FUNC_UNST_CMO = 3 - TA_FuncUnstId TA_FUNC_UNST_DX = 4 - TA_FuncUnstId TA_FUNC_UNST_EMA = 5 - TA_FuncUnstId TA_FUNC_UNST_HT_DCPERIOD = 6 - TA_FuncUnstId TA_FUNC_UNST_HT_DCPHASE = 7 - TA_FuncUnstId TA_FUNC_UNST_HD_PHASOR = 8 - TA_FuncUnstId TA_FUNC_UNST_HT_SINE = 9 - TA_FuncUnstId TA_FUNC_UNST_HT_TRENDLINE = 10 - TA_FuncUnstId TA_FUNC_UNST_HT_TRENDMODE = 11 - TA_FuncUnstId TA_FUNC_UNST_KAMA = 12 - TA_FuncUnstId TA_FUNC_UNST_MAMA = 13 - TA_FuncUnstId TA_FUNC_UNST_MFI = 14 - TA_FuncUnstId TA_FUNC_UNST_MINUS_DI = 15 - TA_FuncUnstId TA_FUNC_UNST_MINUS_DM = 16 - TA_FuncUnstId TA_FUNC_UNST_NATR = 17 - TA_FuncUnstId TA_FUNC_UNST_PLUS_DI = 18 - TA_FuncUnstId TA_FUNC_UNST_PLUS_DM = 19 - TA_FuncUnstId TA_FUNC_UNST_RSI = 20 - TA_FuncUnstId TA_FUNC_UNST_STOCHRSI = 21 - TA_FuncUnstId TA_FUNC_UNST_T3 = 21 - TA_FuncUnstId TA_FUNC_UNST_ALL = 22 - TA_FuncUnstId TA_FUNC_UNST_NONE = -1 + const TA_FuncUnstId TA_FUNC_UNST_ADX = 0 + const TA_FuncUnstId TA_FUNC_UNST_ADXR = 1 + const TA_FuncUnstId TA_FUNC_UNST_ATR = 2 + const TA_FuncUnstId TA_FUNC_UNST_CMO = 3 + const TA_FuncUnstId TA_FUNC_UNST_DX = 4 + const TA_FuncUnstId TA_FUNC_UNST_EMA = 5 + const TA_FuncUnstId TA_FUNC_UNST_HT_DCPERIOD = 6 + const TA_FuncUnstId TA_FUNC_UNST_HT_DCPHASE = 7 + const TA_FuncUnstId TA_FUNC_UNST_HD_PHASOR = 8 + const TA_FuncUnstId TA_FUNC_UNST_HT_SINE = 9 + const TA_FuncUnstId TA_FUNC_UNST_HT_TRENDLINE = 10 + const TA_FuncUnstId TA_FUNC_UNST_HT_TRENDMODE = 11 + const TA_FuncUnstId TA_FUNC_UNST_KAMA = 12 + const TA_FuncUnstId TA_FUNC_UNST_MAMA = 13 + const TA_FuncUnstId TA_FUNC_UNST_MFI = 14 + const TA_FuncUnstId TA_FUNC_UNST_MINUS_DI = 15 + const TA_FuncUnstId TA_FUNC_UNST_MINUS_DM = 16 + const TA_FuncUnstId TA_FUNC_UNST_NATR = 17 + const TA_FuncUnstId TA_FUNC_UNST_PLUS_DI = 18 + const TA_FuncUnstId TA_FUNC_UNST_PLUS_DM = 19 + const TA_FuncUnstId TA_FUNC_UNST_RSI = 20 + const TA_FuncUnstId TA_FUNC_UNST_STOCHRSI = 21 + const TA_FuncUnstId TA_FUNC_UNST_T3 = 21 + const TA_FuncUnstId TA_FUNC_UNST_ALL = 22 + const TA_FuncUnstId TA_FUNC_UNST_NONE = -1 ctypedef int TA_RangeType - TA_RangeType TA_RangeType_RealBody = 0 - TA_RangeType TA_RangeType_HighLow = 1 - TA_RangeType TA_RangeType_Shadows = 2 + const TA_RangeType TA_RangeType_RealBody = 0 + const TA_RangeType TA_RangeType_HighLow = 1 + const TA_RangeType TA_RangeType_Shadows = 2 ctypedef int TA_CandleSettingType - TA_CandleSettingType TA_BodyLong = 0 - TA_CandleSettingType TA_BodyVeryLong = 1 - TA_CandleSettingType TA_BodyShort = 2 - TA_CandleSettingType TA_BodyDoji = 3 - TA_CandleSettingType TA_ShadowLong = 4 - TA_CandleSettingType TA_ShadowVeryLong = 5 - TA_CandleSettingType TA_ShadowShort = 6 - TA_CandleSettingType TA_ShadowVeryShort = 7 - TA_CandleSettingType TA_Near = 8 - TA_CandleSettingType TA_Far = 9 - TA_CandleSettingType TA_Equal = 10 - TA_CandleSettingType TA_AllCandleSettings = 11 + const TA_CandleSettingType TA_BodyLong = 0 + const TA_CandleSettingType TA_BodyVeryLong = 1 + const TA_CandleSettingType TA_BodyShort = 2 + const TA_CandleSettingType TA_BodyDoji = 3 + const TA_CandleSettingType TA_ShadowLong = 4 + const TA_CandleSettingType TA_ShadowVeryLong = 5 + const TA_CandleSettingType TA_ShadowShort = 6 + const TA_CandleSettingType TA_ShadowVeryShort = 7 + const TA_CandleSettingType TA_Near = 8 + const TA_CandleSettingType TA_Far = 9 + const TA_CandleSettingType TA_Equal = 10 + const TA_CandleSettingType TA_AllCandleSettings = 11 cdef extern from "ta-lib/ta_common.h": const char *TA_GetVersionString() @@ -135,19 +135,19 @@ cdef extern from "ta-lib/ta_abstract.h": TA_RetCode TA_GetFuncInfo(const TA_FuncHandle *handle, const TA_FuncInfo **funcInfo) ctypedef int TA_InputParameterType - TA_InputParameterType TA_Input_Price = 0 - TA_InputParameterType TA_Input_Real = 1 - TA_InputParameterType TA_Input_Integer = 2 + const TA_InputParameterType TA_Input_Price = 0 + const TA_InputParameterType TA_Input_Real = 1 + const TA_InputParameterType TA_Input_Integer = 2 ctypedef int TA_OptInputParameterType - TA_OptInputParameterType TA_OptInput_RealRange = 0 - TA_OptInputParameterType TA_OptInput_RealList = 1 - TA_OptInputParameterType TA_OptInput_IntegerRange = 2 - TA_OptInputParameterType TA_OptInput_IntegerList = 3 + const TA_OptInputParameterType TA_OptInput_RealRange = 0 + const TA_OptInputParameterType TA_OptInput_RealList = 1 + const TA_OptInputParameterType TA_OptInput_IntegerRange = 2 + const TA_OptInputParameterType TA_OptInput_IntegerList = 3 ctypedef int TA_OutputParameterType - TA_OutputParameterType TA_Output_Real = 0 - TA_OutputParameterType TA_Output_Integer = 1 + const TA_OutputParameterType TA_Output_Real = 0 + const TA_OutputParameterType TA_Output_Integer = 1 ctypedef int TA_InputFlags ctypedef int TA_OptInputFlags diff --git a/talib/abstract.pyi b/talib/abstract.pyi new file mode 100644 index 000000000..ef6c7da26 --- /dev/null +++ b/talib/abstract.pyi @@ -0,0 +1,2267 @@ + +from typing import overload, Tuple, Union +import numpy as np +import pandas as pd + +"""HT_DCPERIOD(real) + +Hilbert Transform - Dominant Cycle Period (Cycle Indicators) + +Inputs: + real: (any ndarray) +Outputs: + real""" +@overload +def HT_DCPERIOD(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def HT_DCPERIOD(real: pd.DataFrame) -> pd.Series: ... + +"""HT_DCPHASE(real) + +Hilbert Transform - Dominant Cycle Phase (Cycle Indicators) + +Inputs: + real: (any ndarray) +Outputs: + real""" +@overload +def HT_DCPHASE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def HT_DCPHASE(real: pd.DataFrame) -> pd.Series: ... + +"""HT_PHASOR(real) + +Hilbert Transform - Phasor Components (Cycle Indicators) + +Inputs: + real: (any ndarray) +Outputs: + inphase + quadrature""" +@overload +def HT_PHASOR(real: Union[pd.Series, np.ndarray]) -> Tuple[np.ndarray, np.ndarray]: ... +@overload +def HT_PHASOR(real: pd.DataFrame) -> pd.DataFrame: ... + +"""HT_SINE(real) + +Hilbert Transform - SineWave (Cycle Indicators) + +Inputs: + real: (any ndarray) +Outputs: + sine + leadsine""" +@overload +def HT_SINE(real: Union[pd.Series, np.ndarray]) -> Tuple[np.ndarray, np.ndarray]: ... +@overload +def HT_SINE(real: pd.DataFrame) -> pd.DataFrame: ... + +"""HT_TRENDMODE(real) + +Hilbert Transform - Trend vs Cycle Mode (Cycle Indicators) + +Inputs: + real: (any ndarray) +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def HT_TRENDMODE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def HT_TRENDMODE(real: pd.DataFrame) -> pd.Series: ... + +"""ADD(real0, real1) + +Vector Arithmetic Add (Math Operators) + +Inputs: + real0: (any ndarray) + real1: (any ndarray) +Outputs: + real""" +@overload +def ADD(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def ADD(real: pd.DataFrame) -> pd.Series: ... + +"""DIV(real0, real1) + +Vector Arithmetic Div (Math Operators) + +Inputs: + real0: (any ndarray) + real1: (any ndarray) +Outputs: + real""" +@overload +def DIV(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def DIV(real: pd.DataFrame) -> pd.Series: ... + +"""MAX(real[, timeperiod=?]) + +Highest value over a specified period (Math Operators) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 30 +Outputs: + real""" +@overload +def MAX(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... +@overload +def MAX(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... + +"""MAXINDEX(real[, timeperiod=?]) + +Index of highest value over a specified period (Math Operators) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 30 +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def MAXINDEX(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... +@overload +def MAXINDEX(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... + +"""MIN(real[, timeperiod=?]) + +Lowest value over a specified period (Math Operators) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 30 +Outputs: + real""" +@overload +def MIN(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... +@overload +def MIN(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... + +"""MININDEX(real[, timeperiod=?]) + +Index of lowest value over a specified period (Math Operators) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 30 +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def MININDEX(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... +@overload +def MININDEX(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... + +"""MINMAX(real[, timeperiod=?]) + +Lowest and highest values over a specified period (Math Operators) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 30 +Outputs: + min + max""" +@overload +def MINMAX(real: Union[pd.Series, np.ndarray], timeperiod=30) -> Tuple[np.ndarray, np.ndarray]: ... +@overload +def MINMAX(real: pd.DataFrame, timeperiod=30) -> pd.DataFrame: ... + +"""MINMAXINDEX(real[, timeperiod=?]) + +Indexes of lowest and highest values over a specified period (Math Operators) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 30 +Outputs: + minidx + maxidx""" +@overload +def MINMAXINDEX(real: Union[pd.Series, np.ndarray], timeperiod=30) -> Tuple[np.ndarray, np.ndarray]: ... +@overload +def MINMAXINDEX(real: pd.DataFrame, timeperiod=30) -> pd.DataFrame: ... + +"""MULT(real0, real1) + +Vector Arithmetic Mult (Math Operators) + +Inputs: + real0: (any ndarray) + real1: (any ndarray) +Outputs: + real""" +@overload +def MULT(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def MULT(real: pd.DataFrame) -> pd.Series: ... + +"""SUB(real0, real1) + +Vector Arithmetic Subtraction (Math Operators) + +Inputs: + real0: (any ndarray) + real1: (any ndarray) +Outputs: + real""" +@overload +def SUB(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def SUB(real: pd.DataFrame) -> pd.Series: ... + +"""SUM(real[, timeperiod=?]) + +Summation (Math Operators) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 30 +Outputs: + real""" +@overload +def SUM(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... +@overload +def SUM(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... + +"""ACOS(real) + +Vector Trigonometric ACos (Math Transform) + +Inputs: + real: (any ndarray) +Outputs: + real""" +@overload +def ACOS(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def ACOS(real: pd.DataFrame) -> pd.Series: ... + +"""ASIN(real) + +Vector Trigonometric ASin (Math Transform) + +Inputs: + real: (any ndarray) +Outputs: + real""" +@overload +def ASIN(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def ASIN(real: pd.DataFrame) -> pd.Series: ... + +"""ATAN(real) + +Vector Trigonometric ATan (Math Transform) + +Inputs: + real: (any ndarray) +Outputs: + real""" +@overload +def ATAN(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def ATAN(real: pd.DataFrame) -> pd.Series: ... + +"""CEIL(real) + +Vector Ceil (Math Transform) + +Inputs: + real: (any ndarray) +Outputs: + real""" +@overload +def CEIL(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CEIL(real: pd.DataFrame) -> pd.Series: ... + +"""COS(real) + +Vector Trigonometric Cos (Math Transform) + +Inputs: + real: (any ndarray) +Outputs: + real""" +@overload +def COS(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def COS(real: pd.DataFrame) -> pd.Series: ... + +"""COSH(real) + +Vector Trigonometric Cosh (Math Transform) + +Inputs: + real: (any ndarray) +Outputs: + real""" +@overload +def COSH(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def COSH(real: pd.DataFrame) -> pd.Series: ... + +"""EXP(real) + +Vector Arithmetic Exp (Math Transform) + +Inputs: + real: (any ndarray) +Outputs: + real""" +@overload +def EXP(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def EXP(real: pd.DataFrame) -> pd.Series: ... + +"""FLOOR(real) + +Vector Floor (Math Transform) + +Inputs: + real: (any ndarray) +Outputs: + real""" +@overload +def FLOOR(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def FLOOR(real: pd.DataFrame) -> pd.Series: ... + +"""LN(real) + +Vector Log Natural (Math Transform) + +Inputs: + real: (any ndarray) +Outputs: + real""" +@overload +def LN(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def LN(real: pd.DataFrame) -> pd.Series: ... + +"""LOG10(real) + +Vector Log10 (Math Transform) + +Inputs: + real: (any ndarray) +Outputs: + real""" +@overload +def LOG10(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def LOG10(real: pd.DataFrame) -> pd.Series: ... + +"""SIN(real) + +Vector Trigonometric Sin (Math Transform) + +Inputs: + real: (any ndarray) +Outputs: + real""" +@overload +def SIN(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def SIN(real: pd.DataFrame) -> pd.Series: ... + +"""SINH(real) + +Vector Trigonometric Sinh (Math Transform) + +Inputs: + real: (any ndarray) +Outputs: + real""" +@overload +def SINH(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def SINH(real: pd.DataFrame) -> pd.Series: ... + +"""SQRT(real) + +Vector Square Root (Math Transform) + +Inputs: + real: (any ndarray) +Outputs: + real""" +@overload +def SQRT(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def SQRT(real: pd.DataFrame) -> pd.Series: ... + +"""TAN(real) + +Vector Trigonometric Tan (Math Transform) + +Inputs: + real: (any ndarray) +Outputs: + real""" +@overload +def TAN(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def TAN(real: pd.DataFrame) -> pd.Series: ... + +"""TANH(real) + +Vector Trigonometric Tanh (Math Transform) + +Inputs: + real: (any ndarray) +Outputs: + real""" +@overload +def TANH(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def TANH(real: pd.DataFrame) -> pd.Series: ... + +"""ADX(high, low, close[, timeperiod=?]) + +Average Directional Movement Index (Momentum Indicators) + +Inputs: + prices: ['high', 'low', 'close'] +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def ADX(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def ADX(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""ADXR(high, low, close[, timeperiod=?]) + +Average Directional Movement Index Rating (Momentum Indicators) + +Inputs: + prices: ['high', 'low', 'close'] +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def ADXR(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def ADXR(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""APO(real[, fastperiod=?, slowperiod=?, matype=?]) + +Absolute Price Oscillator (Momentum Indicators) + +Inputs: + real: (any ndarray) +Parameters: + fastperiod: 12 + slowperiod: 26 + matype: 0 (Simple Moving Average) +Outputs: + real""" +@overload +def APO(real: Union[pd.Series, np.ndarray], fastperiod=12, slowperiod=26, matype=0) -> np.ndarray: ... +@overload +def APO(real: pd.DataFrame, fastperiod=12, slowperiod=26, matype=0) -> pd.Series: ... + +"""AROON(high, low[, timeperiod=?]) + +Aroon (Momentum Indicators) + +Inputs: + prices: ['high', 'low'] +Parameters: + timeperiod: 14 +Outputs: + aroondown + aroonup""" +@overload +def AROON(real: Union[pd.Series, np.ndarray], timeperiod=14) -> Tuple[np.ndarray, np.ndarray]: ... +@overload +def AROON(real: pd.DataFrame, timeperiod=14) -> pd.DataFrame: ... + +"""AROONOSC(high, low[, timeperiod=?]) + +Aroon Oscillator (Momentum Indicators) + +Inputs: + prices: ['high', 'low'] +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def AROONOSC(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def AROONOSC(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""BOP(open, high, low, close) + +Balance Of Power (Momentum Indicators) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + real""" +@overload +def BOP(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def BOP(real: pd.DataFrame) -> pd.Series: ... + +"""CCI(high, low, close[, timeperiod=?]) + +Commodity Channel Index (Momentum Indicators) + +Inputs: + prices: ['high', 'low', 'close'] +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def CCI(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def CCI(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""CMO(real[, timeperiod=?]) + +Chande Momentum Oscillator (Momentum Indicators) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def CMO(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def CMO(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""DX(high, low, close[, timeperiod=?]) + +Directional Movement Index (Momentum Indicators) + +Inputs: + prices: ['high', 'low', 'close'] +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def DX(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def DX(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""MACD(real[, fastperiod=?, slowperiod=?, signalperiod=?]) + +Moving Average Convergence/Divergence (Momentum Indicators) + +Inputs: + real: (any ndarray) +Parameters: + fastperiod: 12 + slowperiod: 26 + signalperiod: 9 +Outputs: + macd + macdsignal + macdhist""" +@overload +def MACD(real: Union[pd.Series, np.ndarray], fastperiod=12, slowperiod=26, signalperiod=9) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: ... +@overload +def MACD(real: pd.DataFrame, fastperiod=12, slowperiod=26, signalperiod=9) -> pd.DataFrame: ... + +"""MACDEXT(real[, fastperiod=?, fastmatype=?, slowperiod=?, slowmatype=?, signalperiod=?, signalmatype=?]) + +MACD with controllable MA type (Momentum Indicators) + +Inputs: + real: (any ndarray) +Parameters: + fastperiod: 12 + fastmatype: 0 + slowperiod: 26 + slowmatype: 0 + signalperiod: 9 + signalmatype: 0 +Outputs: + macd + macdsignal + macdhist""" +@overload +def MACDEXT(real: Union[pd.Series, np.ndarray], fastperiod=12, fastmatype=0, slowperiod=26, slowmatype=0, signalperiod=9, signalmatype=0) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: ... +@overload +def MACDEXT(real: pd.DataFrame, fastperiod=12, fastmatype=0, slowperiod=26, slowmatype=0, signalperiod=9, signalmatype=0) -> pd.DataFrame: ... + +"""MACDFIX(real[, signalperiod=?]) + +Moving Average Convergence/Divergence Fix 12/26 (Momentum Indicators) + +Inputs: + real: (any ndarray) +Parameters: + signalperiod: 9 +Outputs: + macd + macdsignal + macdhist""" +@overload +def MACDFIX(real: Union[pd.Series, np.ndarray], signalperiod=9) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: ... +@overload +def MACDFIX(real: pd.DataFrame, signalperiod=9) -> pd.DataFrame: ... + +"""MFI(high, low, close, volume[, timeperiod=?]) + +Money Flow Index (Momentum Indicators) + +Inputs: + prices: ['high', 'low', 'close', 'volume'] +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def MFI(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def MFI(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""MINUS_DI(high, low, close[, timeperiod=?]) + +Minus Directional Indicator (Momentum Indicators) + +Inputs: + prices: ['high', 'low', 'close'] +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def MINUS_DI(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def MINUS_DI(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""MINUS_DM(high, low[, timeperiod=?]) + +Minus Directional Movement (Momentum Indicators) + +Inputs: + prices: ['high', 'low'] +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def MINUS_DM(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def MINUS_DM(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""MOM(real[, timeperiod=?]) + +Momentum (Momentum Indicators) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 10 +Outputs: + real""" +@overload +def MOM(real: Union[pd.Series, np.ndarray], timeperiod=10) -> np.ndarray: ... +@overload +def MOM(real: pd.DataFrame, timeperiod=10) -> pd.Series: ... + +"""PLUS_DI(high, low, close[, timeperiod=?]) + +Plus Directional Indicator (Momentum Indicators) + +Inputs: + prices: ['high', 'low', 'close'] +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def PLUS_DI(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def PLUS_DI(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""PLUS_DM(high, low[, timeperiod=?]) + +Plus Directional Movement (Momentum Indicators) + +Inputs: + prices: ['high', 'low'] +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def PLUS_DM(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def PLUS_DM(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""PPO(real[, fastperiod=?, slowperiod=?, matype=?]) + +Percentage Price Oscillator (Momentum Indicators) + +Inputs: + real: (any ndarray) +Parameters: + fastperiod: 12 + slowperiod: 26 + matype: 0 (Simple Moving Average) +Outputs: + real""" +@overload +def PPO(real: Union[pd.Series, np.ndarray], fastperiod=12, slowperiod=26, matype=0) -> np.ndarray: ... +@overload +def PPO(real: pd.DataFrame, fastperiod=12, slowperiod=26, matype=0) -> pd.Series: ... + +"""ROC(real[, timeperiod=?]) + +Rate of change : ((real/prevPrice)-1)*100 (Momentum Indicators) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 10 +Outputs: + real""" +@overload +def ROC(real: Union[pd.Series, np.ndarray], timeperiod=10) -> np.ndarray: ... +@overload +def ROC(real: pd.DataFrame, timeperiod=10) -> pd.Series: ... + +"""ROCP(real[, timeperiod=?]) + +Rate of change Percentage: (real-prevPrice)/prevPrice (Momentum Indicators) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 10 +Outputs: + real""" +@overload +def ROCP(real: Union[pd.Series, np.ndarray], timeperiod=10) -> np.ndarray: ... +@overload +def ROCP(real: pd.DataFrame, timeperiod=10) -> pd.Series: ... + +"""ROCR(real[, timeperiod=?]) + +Rate of change ratio: (real/prevPrice) (Momentum Indicators) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 10 +Outputs: + real""" +@overload +def ROCR(real: Union[pd.Series, np.ndarray], timeperiod=10) -> np.ndarray: ... +@overload +def ROCR(real: pd.DataFrame, timeperiod=10) -> pd.Series: ... + +"""ROCR100(real[, timeperiod=?]) + +Rate of change ratio 100 scale: (real/prevPrice)*100 (Momentum Indicators) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 10 +Outputs: + real""" +@overload +def ROCR100(real: Union[pd.Series, np.ndarray], timeperiod=10) -> np.ndarray: ... +@overload +def ROCR100(real: pd.DataFrame, timeperiod=10) -> pd.Series: ... + +"""RSI(real[, timeperiod=?]) + +Relative Strength Index (Momentum Indicators) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def RSI(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def RSI(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""STOCH(high, low, close[, fastk_period=?, slowk_period=?, slowk_matype=?, slowd_period=?, slowd_matype=?]) + +Stochastic (Momentum Indicators) + +Inputs: + prices: ['high', 'low', 'close'] +Parameters: + fastk_period: 5 + slowk_period: 3 + slowk_matype: 0 + slowd_period: 3 + slowd_matype: 0 +Outputs: + slowk + slowd""" +@overload +def STOCH(real: Union[pd.Series, np.ndarray], fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0) -> Tuple[np.ndarray, np.ndarray]: ... +@overload +def STOCH(real: pd.DataFrame, fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0) -> pd.DataFrame: ... + +"""STOCHF(high, low, close[, fastk_period=?, fastd_period=?, fastd_matype=?]) + +Stochastic Fast (Momentum Indicators) + +Inputs: + prices: ['high', 'low', 'close'] +Parameters: + fastk_period: 5 + fastd_period: 3 + fastd_matype: 0 +Outputs: + fastk + fastd""" +@overload +def STOCHF(real: Union[pd.Series, np.ndarray], fastk_period=5, fastd_period=3, fastd_matype=0) -> Tuple[np.ndarray, np.ndarray]: ... +@overload +def STOCHF(real: pd.DataFrame, fastk_period=5, fastd_period=3, fastd_matype=0) -> pd.DataFrame: ... + +"""STOCHRSI(real[, timeperiod=?, fastk_period=?, fastd_period=?, fastd_matype=?]) + +Stochastic Relative Strength Index (Momentum Indicators) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 14 + fastk_period: 5 + fastd_period: 3 + fastd_matype: 0 +Outputs: + fastk + fastd""" +@overload +def STOCHRSI(real: Union[pd.Series, np.ndarray], timeperiod=14, fastk_period=5, fastd_period=3, fastd_matype=0) -> Tuple[np.ndarray, np.ndarray]: ... +@overload +def STOCHRSI(real: pd.DataFrame, timeperiod=14, fastk_period=5, fastd_period=3, fastd_matype=0) -> pd.DataFrame: ... + +"""TRIX(real[, timeperiod=?]) + +1-day Rate-Of-Change (ROC) of a Triple Smooth EMA (Momentum Indicators) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 30 +Outputs: + real""" +@overload +def TRIX(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... +@overload +def TRIX(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... + +"""ULTOSC(high, low, close[, timeperiod1=?, timeperiod2=?, timeperiod3=?]) + +Ultimate Oscillator (Momentum Indicators) + +Inputs: + prices: ['high', 'low', 'close'] +Parameters: + timeperiod1: 7 + timeperiod2: 14 + timeperiod3: 28 +Outputs: + real""" +@overload +def ULTOSC(real: Union[pd.Series, np.ndarray], timeperiod1=7, timeperiod2=14, timeperiod3=28) -> np.ndarray: ... +@overload +def ULTOSC(real: pd.DataFrame, timeperiod1=7, timeperiod2=14, timeperiod3=28) -> pd.Series: ... + +"""WILLR(high, low, close[, timeperiod=?]) + +Williams' %R (Momentum Indicators) + +Inputs: + prices: ['high', 'low', 'close'] +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def WILLR(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def WILLR(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""BBANDS(real[, timeperiod=?, nbdevup=?, nbdevdn=?, matype=?]) + +Bollinger Bands (Overlap Studies) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 5 + nbdevup: 2.0 + nbdevdn: 2.0 + matype: 0 (Simple Moving Average) +Outputs: + upperband + middleband + lowerband""" +@overload +def BBANDS(real: Union[pd.Series, np.ndarray], timeperiod=5, nbdevup=2.0, nbdevdn=2.0, matype=0) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: ... +@overload +def BBANDS(real: pd.DataFrame, timeperiod=5, nbdevup=2.0, nbdevdn=2.0, matype=0) -> pd.DataFrame: ... + +"""DEMA(real[, timeperiod=?]) + +Double Exponential Moving Average (Overlap Studies) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 30 +Outputs: + real""" +@overload +def DEMA(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... +@overload +def DEMA(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... + +"""EMA(real[, timeperiod=?]) + +Exponential Moving Average (Overlap Studies) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 30 +Outputs: + real""" +@overload +def EMA(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... +@overload +def EMA(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... + +"""HT_TRENDLINE(real) + +Hilbert Transform - Instantaneous Trendline (Overlap Studies) + +Inputs: + real: (any ndarray) +Outputs: + real""" +@overload +def HT_TRENDLINE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def HT_TRENDLINE(real: pd.DataFrame) -> pd.Series: ... + +"""KAMA(real[, timeperiod=?]) + +Kaufman Adaptive Moving Average (Overlap Studies) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 30 +Outputs: + real""" +@overload +def KAMA(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... +@overload +def KAMA(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... + +"""MA(real[, timeperiod=?, matype=?]) + +Moving average (Overlap Studies) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 30 + matype: 0 (Simple Moving Average) +Outputs: + real""" +@overload +def MA(real: Union[pd.Series, np.ndarray], timeperiod=30, matype=0) -> np.ndarray: ... +@overload +def MA(real: pd.DataFrame, timeperiod=30, matype=0) -> pd.Series: ... + +"""MAMA(real[, fastlimit=?, slowlimit=?]) + +MESA Adaptive Moving Average (Overlap Studies) + +Inputs: + real: (any ndarray) +Parameters: + fastlimit: 0.5 + slowlimit: 0.05 +Outputs: + mama + fama""" +@overload +def MAMA(real: Union[pd.Series, np.ndarray], fastlimit=0.5, slowlimit=0.05) -> Tuple[np.ndarray, np.ndarray]: ... +@overload +def MAMA(real: pd.DataFrame, fastlimit=0.5, slowlimit=0.05) -> pd.DataFrame: ... + +"""MAVP(real, periods[, minperiod=?, maxperiod=?, matype=?]) + +Moving average with variable period (Overlap Studies) + +Inputs: + real: (any ndarray) + periods: (any ndarray) +Parameters: + minperiod: 2 + maxperiod: 30 + matype: 0 (Simple Moving Average) +Outputs: + real""" +@overload +def MAVP(real: Union[pd.Series, np.ndarray], minperiod=2, maxperiod=30, matype=0) -> np.ndarray: ... +@overload +def MAVP(real: pd.DataFrame, minperiod=2, maxperiod=30, matype=0) -> pd.Series: ... + +"""MIDPOINT(real[, timeperiod=?]) + +MidPoint over period (Overlap Studies) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def MIDPOINT(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def MIDPOINT(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""MIDPRICE(high, low[, timeperiod=?]) + +Midpoint Price over period (Overlap Studies) + +Inputs: + prices: ['high', 'low'] +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def MIDPRICE(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def MIDPRICE(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""SAR(high, low[, acceleration=?, maximum=?]) + +Parabolic SAR (Overlap Studies) + +Inputs: + prices: ['high', 'low'] +Parameters: + acceleration: 0.02 + maximum: 0.2 +Outputs: + real""" +@overload +def SAR(real: Union[pd.Series, np.ndarray], acceleration=0.02, maximum=0.2) -> np.ndarray: ... +@overload +def SAR(real: pd.DataFrame, acceleration=0.02, maximum=0.2) -> pd.Series: ... + +"""SAREXT(high, low[, startvalue=?, offsetonreverse=?, accelerationinitlong=?, accelerationlong=?, accelerationmaxlong=?, accelerationinitshort=?, accelerationshort=?, accelerationmaxshort=?]) + +Parabolic SAR - Extended (Overlap Studies) + +Inputs: + prices: ['high', 'low'] +Parameters: + startvalue: 0.0 + offsetonreverse: 0.0 + accelerationinitlong: 0.02 + accelerationlong: 0.02 + accelerationmaxlong: 0.2 + accelerationinitshort: 0.02 + accelerationshort: 0.02 + accelerationmaxshort: 0.2 +Outputs: + real""" +@overload +def SAREXT(real: Union[pd.Series, np.ndarray], startvalue=0.0, offsetonreverse=0.0, accelerationinitlong=0.02, accelerationlong=0.02, accelerationmaxlong=0.2, accelerationinitshort=0.02, accelerationshort=0.02, accelerationmaxshort=0.2) -> np.ndarray: ... +@overload +def SAREXT(real: pd.DataFrame, startvalue=0.0, offsetonreverse=0.0, accelerationinitlong=0.02, accelerationlong=0.02, accelerationmaxlong=0.2, accelerationinitshort=0.02, accelerationshort=0.02, accelerationmaxshort=0.2) -> pd.Series: ... + +"""SMA(real[, timeperiod=?]) + +Simple Moving Average (Overlap Studies) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 30 +Outputs: + real""" +@overload +def SMA(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... +@overload +def SMA(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... + +"""T3(real[, timeperiod=?, vfactor=?]) + +Triple Exponential Moving Average (T3) (Overlap Studies) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 5 + vfactor: 0.7 +Outputs: + real""" +@overload +def T3(real: Union[pd.Series, np.ndarray], timeperiod=5, vfactor=0.7) -> np.ndarray: ... +@overload +def T3(real: pd.DataFrame, timeperiod=5, vfactor=0.7) -> pd.Series: ... + +"""TEMA(real[, timeperiod=?]) + +Triple Exponential Moving Average (Overlap Studies) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 30 +Outputs: + real""" +@overload +def TEMA(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... +@overload +def TEMA(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... + +"""TRIMA(real[, timeperiod=?]) + +Triangular Moving Average (Overlap Studies) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 30 +Outputs: + real""" +@overload +def TRIMA(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... +@overload +def TRIMA(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... + +"""WMA(real[, timeperiod=?]) + +Weighted Moving Average (Overlap Studies) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 30 +Outputs: + real""" +@overload +def WMA(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... +@overload +def WMA(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... + +"""CDL2CROWS(open, high, low, close) + +Two Crows (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDL2CROWS(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDL2CROWS(real: pd.DataFrame) -> pd.Series: ... + +"""CDL3BLACKCROWS(open, high, low, close) + +Three Black Crows (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDL3BLACKCROWS(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDL3BLACKCROWS(real: pd.DataFrame) -> pd.Series: ... + +"""CDL3INSIDE(open, high, low, close) + +Three Inside Up/Down (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDL3INSIDE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDL3INSIDE(real: pd.DataFrame) -> pd.Series: ... + +"""CDL3LINESTRIKE(open, high, low, close) + +Three-Line Strike (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDL3LINESTRIKE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDL3LINESTRIKE(real: pd.DataFrame) -> pd.Series: ... + +"""CDL3OUTSIDE(open, high, low, close) + +Three Outside Up/Down (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDL3OUTSIDE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDL3OUTSIDE(real: pd.DataFrame) -> pd.Series: ... + +"""CDL3STARSINSOUTH(open, high, low, close) + +Three Stars In The South (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDL3STARSINSOUTH(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDL3STARSINSOUTH(real: pd.DataFrame) -> pd.Series: ... + +"""CDL3WHITESOLDIERS(open, high, low, close) + +Three Advancing White Soldiers (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDL3WHITESOLDIERS(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDL3WHITESOLDIERS(real: pd.DataFrame) -> pd.Series: ... + +"""CDLABANDONEDBABY(open, high, low, close[, penetration=?]) + +Abandoned Baby (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Parameters: + penetration: 0.3 +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLABANDONEDBABY(real: Union[pd.Series, np.ndarray], penetration=0.3) -> np.ndarray: ... +@overload +def CDLABANDONEDBABY(real: pd.DataFrame, penetration=0.3) -> pd.Series: ... + +"""CDLADVANCEBLOCK(open, high, low, close) + +Advance Block (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLADVANCEBLOCK(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLADVANCEBLOCK(real: pd.DataFrame) -> pd.Series: ... + +"""CDLBELTHOLD(open, high, low, close) + +Belt-hold (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLBELTHOLD(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLBELTHOLD(real: pd.DataFrame) -> pd.Series: ... + +"""CDLBREAKAWAY(open, high, low, close) + +Breakaway (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLBREAKAWAY(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLBREAKAWAY(real: pd.DataFrame) -> pd.Series: ... + +"""CDLCLOSINGMARUBOZU(open, high, low, close) + +Closing Marubozu (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLCLOSINGMARUBOZU(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLCLOSINGMARUBOZU(real: pd.DataFrame) -> pd.Series: ... + +"""CDLCONCEALBABYSWALL(open, high, low, close) + +Concealing Baby Swallow (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLCONCEALBABYSWALL(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLCONCEALBABYSWALL(real: pd.DataFrame) -> pd.Series: ... + +"""CDLCOUNTERATTACK(open, high, low, close) + +Counterattack (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLCOUNTERATTACK(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLCOUNTERATTACK(real: pd.DataFrame) -> pd.Series: ... + +"""CDLDARKCLOUDCOVER(open, high, low, close[, penetration=?]) + +Dark Cloud Cover (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Parameters: + penetration: 0.5 +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLDARKCLOUDCOVER(real: Union[pd.Series, np.ndarray], penetration=0.5) -> np.ndarray: ... +@overload +def CDLDARKCLOUDCOVER(real: pd.DataFrame, penetration=0.5) -> pd.Series: ... + +"""CDLDOJI(open, high, low, close) + +Doji (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLDOJI(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLDOJI(real: pd.DataFrame) -> pd.Series: ... + +"""CDLDOJISTAR(open, high, low, close) + +Doji Star (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLDOJISTAR(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLDOJISTAR(real: pd.DataFrame) -> pd.Series: ... + +"""CDLDRAGONFLYDOJI(open, high, low, close) + +Dragonfly Doji (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLDRAGONFLYDOJI(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLDRAGONFLYDOJI(real: pd.DataFrame) -> pd.Series: ... + +"""CDLENGULFING(open, high, low, close) + +Engulfing Pattern (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLENGULFING(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLENGULFING(real: pd.DataFrame) -> pd.Series: ... + +"""CDLEVENINGDOJISTAR(open, high, low, close[, penetration=?]) + +Evening Doji Star (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Parameters: + penetration: 0.3 +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLEVENINGDOJISTAR(real: Union[pd.Series, np.ndarray], penetration=0.3) -> np.ndarray: ... +@overload +def CDLEVENINGDOJISTAR(real: pd.DataFrame, penetration=0.3) -> pd.Series: ... + +"""CDLEVENINGSTAR(open, high, low, close[, penetration=?]) + +Evening Star (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Parameters: + penetration: 0.3 +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLEVENINGSTAR(real: Union[pd.Series, np.ndarray], penetration=0.3) -> np.ndarray: ... +@overload +def CDLEVENINGSTAR(real: pd.DataFrame, penetration=0.3) -> pd.Series: ... + +"""CDLGAPSIDESIDEWHITE(open, high, low, close) + +Up/Down-gap side-by-side white lines (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLGAPSIDESIDEWHITE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLGAPSIDESIDEWHITE(real: pd.DataFrame) -> pd.Series: ... + +"""CDLGRAVESTONEDOJI(open, high, low, close) + +Gravestone Doji (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLGRAVESTONEDOJI(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLGRAVESTONEDOJI(real: pd.DataFrame) -> pd.Series: ... + +"""CDLHAMMER(open, high, low, close) + +Hammer (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLHAMMER(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLHAMMER(real: pd.DataFrame) -> pd.Series: ... + +"""CDLHANGINGMAN(open, high, low, close) + +Hanging Man (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLHANGINGMAN(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLHANGINGMAN(real: pd.DataFrame) -> pd.Series: ... + +"""CDLHARAMI(open, high, low, close) + +Harami Pattern (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLHARAMI(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLHARAMI(real: pd.DataFrame) -> pd.Series: ... + +"""CDLHARAMICROSS(open, high, low, close) + +Harami Cross Pattern (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLHARAMICROSS(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLHARAMICROSS(real: pd.DataFrame) -> pd.Series: ... + +"""CDLHIGHWAVE(open, high, low, close) + +High-Wave Candle (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLHIGHWAVE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLHIGHWAVE(real: pd.DataFrame) -> pd.Series: ... + +"""CDLHIKKAKE(open, high, low, close) + +Hikkake Pattern (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLHIKKAKE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLHIKKAKE(real: pd.DataFrame) -> pd.Series: ... + +"""CDLHIKKAKEMOD(open, high, low, close) + +Modified Hikkake Pattern (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLHIKKAKEMOD(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLHIKKAKEMOD(real: pd.DataFrame) -> pd.Series: ... + +"""CDLHOMINGPIGEON(open, high, low, close) + +Homing Pigeon (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLHOMINGPIGEON(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLHOMINGPIGEON(real: pd.DataFrame) -> pd.Series: ... + +"""CDLIDENTICAL3CROWS(open, high, low, close) + +Identical Three Crows (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLIDENTICAL3CROWS(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLIDENTICAL3CROWS(real: pd.DataFrame) -> pd.Series: ... + +"""CDLINNECK(open, high, low, close) + +In-Neck Pattern (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLINNECK(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLINNECK(real: pd.DataFrame) -> pd.Series: ... + +"""CDLINVERTEDHAMMER(open, high, low, close) + +Inverted Hammer (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLINVERTEDHAMMER(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLINVERTEDHAMMER(real: pd.DataFrame) -> pd.Series: ... + +"""CDLKICKING(open, high, low, close) + +Kicking (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLKICKING(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLKICKING(real: pd.DataFrame) -> pd.Series: ... + +"""CDLKICKINGBYLENGTH(open, high, low, close) + +Kicking - bull/bear determined by the longer marubozu (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLKICKINGBYLENGTH(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLKICKINGBYLENGTH(real: pd.DataFrame) -> pd.Series: ... + +"""CDLLADDERBOTTOM(open, high, low, close) + +Ladder Bottom (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLLADDERBOTTOM(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLLADDERBOTTOM(real: pd.DataFrame) -> pd.Series: ... + +"""CDLLONGLEGGEDDOJI(open, high, low, close) + +Long Legged Doji (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLLONGLEGGEDDOJI(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLLONGLEGGEDDOJI(real: pd.DataFrame) -> pd.Series: ... + +"""CDLLONGLINE(open, high, low, close) + +Long Line Candle (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLLONGLINE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLLONGLINE(real: pd.DataFrame) -> pd.Series: ... + +"""CDLMARUBOZU(open, high, low, close) + +Marubozu (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLMARUBOZU(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLMARUBOZU(real: pd.DataFrame) -> pd.Series: ... + +"""CDLMATCHINGLOW(open, high, low, close) + +Matching Low (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLMATCHINGLOW(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLMATCHINGLOW(real: pd.DataFrame) -> pd.Series: ... + +"""CDLMATHOLD(open, high, low, close[, penetration=?]) + +Mat Hold (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Parameters: + penetration: 0.5 +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLMATHOLD(real: Union[pd.Series, np.ndarray], penetration=0.5) -> np.ndarray: ... +@overload +def CDLMATHOLD(real: pd.DataFrame, penetration=0.5) -> pd.Series: ... + +"""CDLMORNINGDOJISTAR(open, high, low, close[, penetration=?]) + +Morning Doji Star (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Parameters: + penetration: 0.3 +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLMORNINGDOJISTAR(real: Union[pd.Series, np.ndarray], penetration=0.3) -> np.ndarray: ... +@overload +def CDLMORNINGDOJISTAR(real: pd.DataFrame, penetration=0.3) -> pd.Series: ... + +"""CDLMORNINGSTAR(open, high, low, close[, penetration=?]) + +Morning Star (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Parameters: + penetration: 0.3 +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLMORNINGSTAR(real: Union[pd.Series, np.ndarray], penetration=0.3) -> np.ndarray: ... +@overload +def CDLMORNINGSTAR(real: pd.DataFrame, penetration=0.3) -> pd.Series: ... + +"""CDLONNECK(open, high, low, close) + +On-Neck Pattern (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLONNECK(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLONNECK(real: pd.DataFrame) -> pd.Series: ... + +"""CDLPIERCING(open, high, low, close) + +Piercing Pattern (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLPIERCING(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLPIERCING(real: pd.DataFrame) -> pd.Series: ... + +"""CDLRICKSHAWMAN(open, high, low, close) + +Rickshaw Man (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLRICKSHAWMAN(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLRICKSHAWMAN(real: pd.DataFrame) -> pd.Series: ... + +"""CDLRISEFALL3METHODS(open, high, low, close) + +Rising/Falling Three Methods (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLRISEFALL3METHODS(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLRISEFALL3METHODS(real: pd.DataFrame) -> pd.Series: ... + +"""CDLSEPARATINGLINES(open, high, low, close) + +Separating Lines (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLSEPARATINGLINES(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLSEPARATINGLINES(real: pd.DataFrame) -> pd.Series: ... + +"""CDLSHOOTINGSTAR(open, high, low, close) + +Shooting Star (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLSHOOTINGSTAR(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLSHOOTINGSTAR(real: pd.DataFrame) -> pd.Series: ... + +"""CDLSHORTLINE(open, high, low, close) + +Short Line Candle (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLSHORTLINE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLSHORTLINE(real: pd.DataFrame) -> pd.Series: ... + +"""CDLSPINNINGTOP(open, high, low, close) + +Spinning Top (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLSPINNINGTOP(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLSPINNINGTOP(real: pd.DataFrame) -> pd.Series: ... + +"""CDLSTALLEDPATTERN(open, high, low, close) + +Stalled Pattern (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLSTALLEDPATTERN(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLSTALLEDPATTERN(real: pd.DataFrame) -> pd.Series: ... + +"""CDLSTICKSANDWICH(open, high, low, close) + +Stick Sandwich (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLSTICKSANDWICH(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLSTICKSANDWICH(real: pd.DataFrame) -> pd.Series: ... + +"""CDLTAKURI(open, high, low, close) + +Takuri (Dragonfly Doji with very long lower shadow) (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLTAKURI(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLTAKURI(real: pd.DataFrame) -> pd.Series: ... + +"""CDLTASUKIGAP(open, high, low, close) + +Tasuki Gap (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLTASUKIGAP(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLTASUKIGAP(real: pd.DataFrame) -> pd.Series: ... + +"""CDLTHRUSTING(open, high, low, close) + +Thrusting Pattern (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLTHRUSTING(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLTHRUSTING(real: pd.DataFrame) -> pd.Series: ... + +"""CDLTRISTAR(open, high, low, close) + +Tristar Pattern (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLTRISTAR(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLTRISTAR(real: pd.DataFrame) -> pd.Series: ... + +"""CDLUNIQUE3RIVER(open, high, low, close) + +Unique 3 River (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLUNIQUE3RIVER(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLUNIQUE3RIVER(real: pd.DataFrame) -> pd.Series: ... + +"""CDLUPSIDEGAP2CROWS(open, high, low, close) + +Upside Gap Two Crows (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLUPSIDEGAP2CROWS(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLUPSIDEGAP2CROWS(real: pd.DataFrame) -> pd.Series: ... + +"""CDLXSIDEGAP3METHODS(open, high, low, close) + +Upside/Downside Gap Three Methods (Pattern Recognition) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + integer (values are -100, 0 or 100)""" +@overload +def CDLXSIDEGAP3METHODS(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CDLXSIDEGAP3METHODS(real: pd.DataFrame) -> pd.Series: ... + +"""AVGPRICE(open, high, low, close) + +Average Price (Price Transform) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + real""" +@overload +def AVGPRICE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def AVGPRICE(real: pd.DataFrame) -> pd.Series: ... + +"""MEDPRICE(high, low) + +Median Price (Price Transform) + +Inputs: + prices: ['high', 'low'] +Outputs: + real""" +@overload +def MEDPRICE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def MEDPRICE(real: pd.DataFrame) -> pd.Series: ... + +"""TYPPRICE(high, low, close) + +Typical Price (Price Transform) + +Inputs: + prices: ['high', 'low', 'close'] +Outputs: + real""" +@overload +def TYPPRICE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def TYPPRICE(real: pd.DataFrame) -> pd.Series: ... + +"""WCLPRICE(high, low, close) + +Weighted Close Price (Price Transform) + +Inputs: + prices: ['high', 'low', 'close'] +Outputs: + real""" +@overload +def WCLPRICE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def WCLPRICE(real: pd.DataFrame) -> pd.Series: ... + +"""BETA(real0, real1[, timeperiod=?]) + +Beta (Statistic Functions) + +Inputs: + real0: (any ndarray) + real1: (any ndarray) +Parameters: + timeperiod: 5 +Outputs: + real""" +@overload +def BETA(real: Union[pd.Series, np.ndarray], timeperiod=5) -> np.ndarray: ... +@overload +def BETA(real: pd.DataFrame, timeperiod=5) -> pd.Series: ... + +"""CORREL(real0, real1[, timeperiod=?]) + +Pearson's Correlation Coefficient (r) (Statistic Functions) + +Inputs: + real0: (any ndarray) + real1: (any ndarray) +Parameters: + timeperiod: 30 +Outputs: + real""" +@overload +def CORREL(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... +@overload +def CORREL(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... + +"""LINEARREG(real[, timeperiod=?]) + +Linear Regression (Statistic Functions) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def LINEARREG(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def LINEARREG(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""LINEARREG_ANGLE(real[, timeperiod=?]) + +Linear Regression Angle (Statistic Functions) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def LINEARREG_ANGLE(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def LINEARREG_ANGLE(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""LINEARREG_INTERCEPT(real[, timeperiod=?]) + +Linear Regression Intercept (Statistic Functions) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def LINEARREG_INTERCEPT(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def LINEARREG_INTERCEPT(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""LINEARREG_SLOPE(real[, timeperiod=?]) + +Linear Regression Slope (Statistic Functions) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def LINEARREG_SLOPE(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def LINEARREG_SLOPE(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""STDDEV(real[, timeperiod=?, nbdev=?]) + +Standard Deviation (Statistic Functions) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 5 + nbdev: 1.0 +Outputs: + real""" +@overload +def STDDEV(real: Union[pd.Series, np.ndarray], timeperiod=5, nbdev=1.0) -> np.ndarray: ... +@overload +def STDDEV(real: pd.DataFrame, timeperiod=5, nbdev=1.0) -> pd.Series: ... + +"""TSF(real[, timeperiod=?]) + +Time Series Forecast (Statistic Functions) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def TSF(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def TSF(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""VAR(real[, timeperiod=?, nbdev=?]) + +Variance (Statistic Functions) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 5 + nbdev: 1.0 +Outputs: + real""" +@overload +def VAR(real: Union[pd.Series, np.ndarray], timeperiod=5, nbdev=1.0) -> np.ndarray: ... +@overload +def VAR(real: pd.DataFrame, timeperiod=5, nbdev=1.0) -> pd.Series: ... + +"""ATR(high, low, close[, timeperiod=?]) + +Average True Range (Volatility Indicators) + +Inputs: + prices: ['high', 'low', 'close'] +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def ATR(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def ATR(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""NATR(high, low, close[, timeperiod=?]) + +Normalized Average True Range (Volatility Indicators) + +Inputs: + prices: ['high', 'low', 'close'] +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def NATR(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def NATR(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""TRANGE(high, low, close) + +True Range (Volatility Indicators) + +Inputs: + prices: ['high', 'low', 'close'] +Outputs: + real""" +@overload +def TRANGE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def TRANGE(real: pd.DataFrame) -> pd.Series: ... + +"""AD(high, low, close, volume) + +Chaikin A/D Line (Volume Indicators) + +Inputs: + prices: ['high', 'low', 'close', 'volume'] +Outputs: + real""" +@overload +def AD(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def AD(real: pd.DataFrame) -> pd.Series: ... + +"""ADOSC(high, low, close, volume[, fastperiod=?, slowperiod=?]) + +Chaikin A/D Oscillator (Volume Indicators) + +Inputs: + prices: ['high', 'low', 'close', 'volume'] +Parameters: + fastperiod: 3 + slowperiod: 10 +Outputs: + real""" +@overload +def ADOSC(real: Union[pd.Series, np.ndarray], fastperiod=3, slowperiod=10) -> np.ndarray: ... +@overload +def ADOSC(real: pd.DataFrame, fastperiod=3, slowperiod=10) -> pd.Series: ... + +"""OBV(real, volume) + +On Balance Volume (Volume Indicators) + +Inputs: + real: (any ndarray) + prices: ['volume'] +Outputs: + real""" +@overload +def OBV(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def OBV(real: pd.DataFrame) -> pd.Series: ... + diff --git a/tests/conftest.py b/tests/conftest.py index 9756ae7dd..03a8f9481 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,5 +1,3 @@ -from __future__ import print_function - import pytest import numpy as np diff --git a/tests/test_abstract.py b/tests/test_abstract.py index 338518608..c7440e58c 100644 --- a/tests/test_abstract.py +++ b/tests/test_abstract.py @@ -20,6 +20,11 @@ def assert_array_not_equal(x, y): assert_raises(AssertionError, assert_array_equal, x, y) +def test_pararmeters(): + parameters = abstract.MACD.parameters + assert all(type(v) == int for k, v in parameters.items()) + + def test_pandas(ford_2012): import pandas input_df = pandas.DataFrame(ford_2012) diff --git a/tests/test_func.py b/tests/test_func.py index de45f824a..62309424f 100644 --- a/tests/test_func.py +++ b/tests/test_func.py @@ -7,11 +7,11 @@ def test_talib_version(): - assert talib.__ta_version__[:5] == b'0.6.4' + assert talib.__ta_version__[:5] == b'0.7.1' def test_num_functions(): - assert len(talib.get_functions()) == 158 + assert len(talib.get_functions()) == 161 def test_input_wrong_type(): diff --git a/tests/test_stream.py b/tests/test_stream.py index 68fb18602..afb99edcf 100644 --- a/tests/test_stream.py +++ b/tests/test_stream.py @@ -1,7 +1,6 @@ import numpy as np import pandas as pd -import talib from talib import stream diff --git a/tools/build_talib_from_source.bash b/tools/build_talib_from_source.bash deleted file mode 100755 index 328630da7..000000000 --- a/tools/build_talib_from_source.bash +++ /dev/null @@ -1,26 +0,0 @@ -#!/bin/bash -set -e - -if [[ -z $1 ]]; then - echo "Usage: $0 deps_dir" - exit 1 -fi - -DEPS_DIR=$1 - -TA_LIB_TGZ="ta-lib-0.6.4-src.tar.gz" -TA_LIB_URL="https://github.com/TA-Lib/ta-lib/releases/download/v0.6.4/$TA_LIB_TGZ" - -if [[ -d $DEPS_DIR/lib ]]; then - echo "Already built" - exit 0 -fi -mkdir -p $DEPS_DIR/tmp -wget -O "$DEPS_DIR/tmp/$TA_LIB_TGZ" $TA_LIB_URL -pushd $DEPS_DIR/tmp -tar -zxvf $TA_LIB_TGZ -popd -pushd $DEPS_DIR/tmp/ta-lib-0.6.4 -./configure --prefix=$DEPS_DIR -make install -popd diff --git a/tools/build_talib_linux.sh b/tools/build_talib_linux.sh new file mode 100644 index 000000000..361519c34 --- /dev/null +++ b/tools/build_talib_linux.sh @@ -0,0 +1,53 @@ +#!/bin/bash + +TALIB_C_VER="${TALIB_C_VER:=0.7.1}" +CMAKE_GENERATOR="Unix Makefiles" +CMAKE_BUILD_TYPE=Release +CMAKE_CONFIGURATION_TYPES=Release + +# Download TA-Lib C Library +curl -L -o talib-${TALIB_C_VER}.zip https://github.com/TA-Lib/ta-lib/archive/refs/tags/v${TALIB_C_VER}.zip +if [ $? -ne 0 ]; then + echo "Failed to download TA-Lib C library" + exit 1 +fi + +# Unzip TA-Lib C +unzip -q talib-${TALIB_C_VER}.zip +if [ $? -ne 0 ]; then + echo "Failed to extract TA-Lib C library" + exit 1 +fi + +# cd to TA-Lib C +cd ta-lib-${TALIB_C_VER} + +# Copy TA-Lib C headers to TA-Lib Python +mkdir -p include/ta-lib/ +cp include/*.h include/ta-lib/ + +# Create build directory +mkdir -p _build +cd _build + +# Use CMake to configure the build +cmake -G "$CMAKE_GENERATOR" -DCMAKE_BUILD_TYPE=$CMAKE_BUILD_TYPE -DCMAKE_INSTALL_PREFIX=../../ta-lib-install .. +if [ $? -ne 0 ]; then + echo "CMake configuration failed" + exit 1 +fi + +# Compile TA-Lib +make +if [ $? -ne 0 ]; then + echo "Build failed" + exit 1 +fi + +make install +if [ $? -ne 0 ]; then + echo "Install failed" + exit 1 +fi + +echo "TA-Lib build completed successfully!" diff --git a/tools/build_talib_macos.sh b/tools/build_talib_macos.sh new file mode 100644 index 000000000..361519c34 --- /dev/null +++ b/tools/build_talib_macos.sh @@ -0,0 +1,53 @@ +#!/bin/bash + +TALIB_C_VER="${TALIB_C_VER:=0.7.1}" +CMAKE_GENERATOR="Unix Makefiles" +CMAKE_BUILD_TYPE=Release +CMAKE_CONFIGURATION_TYPES=Release + +# Download TA-Lib C Library +curl -L -o talib-${TALIB_C_VER}.zip https://github.com/TA-Lib/ta-lib/archive/refs/tags/v${TALIB_C_VER}.zip +if [ $? -ne 0 ]; then + echo "Failed to download TA-Lib C library" + exit 1 +fi + +# Unzip TA-Lib C +unzip -q talib-${TALIB_C_VER}.zip +if [ $? -ne 0 ]; then + echo "Failed to extract TA-Lib C library" + exit 1 +fi + +# cd to TA-Lib C +cd ta-lib-${TALIB_C_VER} + +# Copy TA-Lib C headers to TA-Lib Python +mkdir -p include/ta-lib/ +cp include/*.h include/ta-lib/ + +# Create build directory +mkdir -p _build +cd _build + +# Use CMake to configure the build +cmake -G "$CMAKE_GENERATOR" -DCMAKE_BUILD_TYPE=$CMAKE_BUILD_TYPE -DCMAKE_INSTALL_PREFIX=../../ta-lib-install .. +if [ $? -ne 0 ]; then + echo "CMake configuration failed" + exit 1 +fi + +# Compile TA-Lib +make +if [ $? -ne 0 ]; then + echo "Build failed" + exit 1 +fi + +make install +if [ $? -ne 0 ]; then + echo "Install failed" + exit 1 +fi + +echo "TA-Lib build completed successfully!" diff --git a/tools/build_talib_windows.cmd b/tools/build_talib_windows.cmd new file mode 100644 index 000000000..187009e75 --- /dev/null +++ b/tools/build_talib_windows.cmd @@ -0,0 +1,38 @@ +:: Download and build TA-Lib +@echo on + +if not defined TALIB_C_VER set TALIB_C_VER=0.7.1 + +set CMAKE_GENERATOR=NMake Makefiles +set CMAKE_BUILD_TYPE=Release +set CMAKE_CONFIGURATION_TYPES=Release + +curl -L -o talib-%TALIB_C_VER%.zip https://github.com/TA-Lib/ta-lib/archive/refs/tags/v%TALIB_C_VER%.zip +if errorlevel 1 exit /B 1 + +tar -xzvf talib-%TALIB_C_VER%.zip +if errorlevel 1 exit /B 1 + +:: git apply --verbose --binary talib.diff +:: if errorlevel 1 exit /B 1 + +:: set MSBUILDTREATHIGHERTOOLSVERSIONASCURRENT + +setlocal +cd ta-lib-%TALIB_C_VER% + +mkdir include\ta-lib +copy /Y include\*.* include\ta-lib + +md _build +cd _build + +cmake.exe .. +if errorlevel 1 exit /B 1 + +nmake.exe /nologo all +if errorlevel 1 exit /B 1 + +copy /Y /B ta-lib-static.lib ta-lib.lib + +endlocal diff --git a/tools/example.py b/tools/example.py index 87c35b522..75a6d3fc1 100644 --- a/tools/example.py +++ b/tools/example.py @@ -1,5 +1,3 @@ -from __future__ import print_function - import sys import numpy as np import pylab diff --git a/tools/generate_abstract_stub.py b/tools/generate_abstract_stub.py new file mode 100644 index 000000000..af60df4a6 --- /dev/null +++ b/tools/generate_abstract_stub.py @@ -0,0 +1,86 @@ +import inspect +import talib +import talib.abstract as abstract + +HEADER = """ +from typing import overload, Tuple, Union +import numpy as np +import pandas as pd +""" + +NUMPY = "np.ndarray" +SERIES = "pd.Series" +DATAFRAME = "pd.DataFrame" + + +def parse_signature(name: str) -> str: + """ + Return a comma-separated function signature for the given TA-Lib abstract function + using the latest talib (OrderedDict parameters) + """ + func = abstract.Function(name) + func_info = func.info + params = ["real"] # always first + + for param_name, default_val in func_info["parameters"].items(): + if default_val is not None: + params.append(f"{param_name}={repr(default_val)}") + else: + params.append(param_name) + + return ", ".join(params) + + +def output_type(func): + outputs = func.output_names + + if len(outputs) == 1: + return NUMPY, SERIES + + tuple_np_type = f"Tuple[{', '.join([NUMPY]*len(outputs))}]" + + return tuple_np_type, DATAFRAME + + +def clean_doc(doc): + # Remove redundant first line + return "\n".join(doc.splitlines()[1:]).strip() + + +def generate_function(name: str): + func = abstract.Function(name) + + params = parse_signature(name) + np_type, pd_type = output_type(func) + + # get talib module docstring (Python-level) + doc = clean_doc(inspect.getdoc(getattr(talib, name))) + + lines = [] + + if doc: + lines.append(f'"""{doc}"""') + + # Union overload for Series + ndarray (catches both) + union_params = params.replace("real", "real: Union[pd.Series, np.ndarray]") + lines.append("@overload") + lines.append(f"def {name}({union_params}) -> {np_type}: ...") + + # DataFrame overload + df_params = params.replace("real", "real: pd.DataFrame") + lines.append("@overload") + lines.append(f"def {name}({df_params}) -> {pd_type}: ...") + + return "\n".join(lines) + + +def main(): + print(HEADER) + + for name in talib.get_functions(): + print(generate_function(name)) + print() + + +if __name__ == "__main__": + main() diff --git a/tools/generate_func.py b/tools/generate_func.py index 185909083..6dbb4b100 100644 --- a/tools/generate_func.py +++ b/tools/generate_func.py @@ -1,5 +1,3 @@ -from __future__ import print_function - import os import re import sys diff --git a/tools/generate_stream.py b/tools/generate_stream.py index 7029c989d..7d6af3f68 100644 --- a/tools/generate_stream.py +++ b/tools/generate_stream.py @@ -1,5 +1,3 @@ -from __future__ import print_function - import os import re import sys diff --git a/tools/install-macos.sh b/tools/install-macos.sh deleted file mode 100644 index a84ff3adc..000000000 --- a/tools/install-macos.sh +++ /dev/null @@ -1,8 +0,0 @@ -#!/bin/bash - -brew install ta-lib - -export TA_INCLUDE_PATH="$(brew --prefix ta-lib)/include" -export TA_LIBRARY_PATH="$(brew --prefix ta-lib)/lib" - -pip3 install ta-lib diff --git a/tools/install-ubuntu.sh b/tools/install-ubuntu.sh deleted file mode 100644 index 6fbb436e3..000000000 --- a/tools/install-ubuntu.sh +++ /dev/null @@ -1,25 +0,0 @@ -apt update -yes | apt-get install gcc build-essential python3-distutils python3-dev python3-pip - -wget http://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz - -tar -zxvf ta-lib-0.4.0-src.tar.gz - -rm ta-lib-0.4.0-src.tar.gz - -cd ta-lib - -if [[ `id -un` == "root" ]] - then - ./configure - make - make install - else - ./configure --prefix=/usr - make - make install -fi - - -yes | pip3 install setuptools -yes | pip3 install Ta-LIB diff --git a/tools/perf_talib.py b/tools/perf_talib.py index 5a3377d4a..010d00bad 100644 --- a/tools/perf_talib.py +++ b/tools/perf_talib.py @@ -1,7 +1,6 @@ -from __future__ import print_function - import numpy import talib +import time import sys TEST_LEN = int(sys.argv[1]) if len(sys.argv) > 1 else 10000 @@ -12,7 +11,6 @@ if False: # fill array with nans data[:-1] = numpy.nan -import time t0 = time.time() for _ in range(LOOPS): talib.MA(data) diff --git a/tools/threads_talib.py b/tools/threads_talib.py index 12e922b17..036ae07da 100644 --- a/tools/threads_talib.py +++ b/tools/threads_talib.py @@ -1,4 +1,3 @@ -from __future__ import print_function import time import threading